1 /* 2 * Copyright (c) 1995 3 * Bill Paul <wpaul@ctr.columbia.edu>. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by Bill Paul. 16 * 4. Neither the name of the author nor the names of any co-contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 * 32 * $FreeBSD: src/libexec/ypxfr/ypxfr_misc.c,v 1.9.2.2 2002/02/15 00:46:54 des Exp $ 33 * $DragonFly: src/libexec/ypxfr/ypxfr_misc.c,v 1.2 2003/06/17 04:27:08 dillon Exp $ 34 */ 35 36 #include <stdio.h> 37 #include <string.h> 38 #include <stdlib.h> 39 #include <unistd.h> 40 #include <sys/param.h> 41 #include <rpc/rpc.h> 42 #include <rpcsvc/yp.h> 43 struct dom_binding {}; 44 #include <rpcsvc/ypclnt.h> 45 #include "ypxfr_extern.h" 46 47 char *ypxfrerr_string(code) 48 ypxfrstat code; 49 { 50 switch (code) { 51 case YPXFR_SUCC: 52 return ("Map successfully transferred"); 53 break; 54 case YPXFR_AGE: 55 return ("Master's version not newer"); 56 break; 57 case YPXFR_NOMAP: 58 return ("No such map in server's domain"); 59 break; 60 case YPXFR_NODOM: 61 return ("Domain not supported by server"); 62 break; 63 case YPXFR_RSRC: 64 return ("Local resource allocation failure"); 65 break; 66 case YPXFR_RPC: 67 return ("RPC failure talking to server"); 68 break; 69 case YPXFR_MADDR: 70 return ("Could not get master server address"); 71 break; 72 case YPXFR_YPERR: 73 return ("NIS server/map database error"); 74 break; 75 case YPXFR_BADARGS: 76 return ("Request arguments bad"); 77 break; 78 case YPXFR_DBM: 79 return ("Local database operation failed"); 80 break; 81 case YPXFR_FILE: 82 return ("Local file I/O operation failed"); 83 break; 84 case YPXFR_SKEW: 85 return ("Map version skew during transfer"); 86 break; 87 case YPXFR_CLEAR: 88 return ("Couldn't send \"clear\" request to local ypserv"); 89 break; 90 case YPXFR_FORCE: 91 return ("No local order number in map -- use -f flag"); 92 break; 93 case YPXFR_XFRERR: 94 return ("General ypxfr error"); 95 break; 96 case YPXFR_REFUSED: 97 return ("Transfer request refused by ypserv"); 98 break; 99 default: 100 return ("Unknown error code"); 101 break; 102 } 103 } 104 105 /* 106 * These are wrappers for the usual yp_master() and yp_order() functions. 107 * They can use either local yplib functions (the real yp_master() and 108 * yp_order()) or do direct RPCs to a specified server. The latter is 109 * necessary if ypxfr is run on a machine that isn't configured as an 110 * NIS client (this can happen very easily: a given machine need not be 111 * an NIS client in order to be an NIS server). 112 */ 113 114 /* 115 * Careful: yp_master() returns a pointer to a dynamically allocated 116 * buffer. Calling ypproc_master_2() ourselves also returns a pointer 117 * to dynamically allocated memory, though this time it's memory 118 * allocated by the XDR routines. We have to rememver to free() or 119 * xdr_free() the memory as required to avoid leaking memory. 120 */ 121 char *ypxfr_get_master(domain,map,source,yplib) 122 char *domain; 123 char *map; 124 char *source; 125 const int yplib; 126 { 127 static char mastername[MAXPATHLEN + 2]; 128 129 bzero((char *)&mastername, sizeof(mastername)); 130 131 if (yplib) { 132 int res; 133 char *master; 134 if ((res = yp_master(domain, map, &master))) { 135 switch (res) { 136 case YPERR_DOMAIN: 137 yp_errno = YPXFR_NODOM; 138 break; 139 case YPERR_MAP: 140 yp_errno = YPXFR_NOMAP; 141 break; 142 case YPERR_YPERR: 143 default: 144 yp_errno = YPXFR_YPERR; 145 break; 146 } 147 return(NULL); 148 } else { 149 snprintf(mastername, sizeof(mastername), "%s", master); 150 free(master); 151 return((char *)&mastername); 152 } 153 } else { 154 CLIENT *clnt; 155 ypresp_master *resp; 156 ypreq_nokey req; 157 158 if ((clnt = clnt_create(source,YPPROG,YPVERS,"udp")) == NULL) { 159 yp_error("%s",clnt_spcreateerror("failed to \ 160 create udp handle to ypserv")); 161 yp_errno = YPXFR_RPC; 162 return(NULL); 163 } 164 165 req.map = map; 166 req.domain = domain; 167 if ((resp = ypproc_master_2(&req, clnt)) == NULL) { 168 yp_error("%s",clnt_sperror(clnt,"YPPROC_MASTER \ 169 failed")); 170 clnt_destroy(clnt); 171 yp_errno = YPXFR_RPC; 172 return(NULL); 173 } 174 clnt_destroy(clnt); 175 if (resp->stat != YP_TRUE) { 176 switch (resp->stat) { 177 case YP_NODOM: 178 yp_errno = YPXFR_NODOM; 179 break; 180 case YP_NOMAP: 181 yp_errno = YPXFR_NOMAP; 182 break; 183 case YP_YPERR: 184 default: 185 yp_errno = YPXFR_YPERR; 186 break; 187 } 188 return(NULL); 189 } 190 snprintf(mastername, sizeof(mastername), "%s", resp->peer); 191 /* xdr_free(xdr_ypresp_master, (char *)&resp); */ 192 return((char *)&mastername); 193 } 194 } 195 196 unsigned long ypxfr_get_order(domain, map, source, yplib) 197 char *domain; 198 char *map; 199 char *source; 200 const int yplib; 201 { 202 if (yplib) { 203 unsigned long order; 204 int res; 205 if ((res = yp_order(domain, map, (int *)&order))) { 206 switch (res) { 207 case YPERR_DOMAIN: 208 yp_errno = YPXFR_NODOM; 209 break; 210 case YPERR_MAP: 211 yp_errno = YPXFR_NOMAP; 212 break; 213 case YPERR_YPERR: 214 default: 215 yp_errno = YPXFR_YPERR; 216 break; 217 } 218 return(0); 219 } else 220 return(order); 221 } else { 222 CLIENT *clnt; 223 ypresp_order *resp; 224 ypreq_nokey req; 225 226 if ((clnt = clnt_create(source,YPPROG,YPVERS,"udp")) == NULL) { 227 yp_error("%s",clnt_spcreateerror("couldn't create \ 228 udp handle to ypserv")); 229 yp_errno = YPXFR_RPC; 230 return(0); 231 } 232 req.map = map; 233 req.domain = domain; 234 if ((resp = ypproc_order_2(&req, clnt)) == NULL) { 235 yp_error("%s", clnt_sperror(clnt, "YPPROC_ORDER \ 236 failed")); 237 clnt_destroy(clnt); 238 yp_errno = YPXFR_RPC; 239 return(0); 240 } 241 clnt_destroy(clnt); 242 if (resp->stat != YP_TRUE) { 243 switch (resp->stat) { 244 case YP_NODOM: 245 yp_errno = YPXFR_NODOM; 246 break; 247 case YP_NOMAP: 248 yp_errno = YPXFR_NOMAP; 249 break; 250 case YP_YPERR: 251 default: 252 yp_errno = YPXFR_YPERR; 253 break; 254 } 255 return(0); 256 } 257 return(resp->ordernum); 258 } 259 } 260 261 int ypxfr_match(server, domain, map, key, keylen) 262 char *server; 263 char *domain; 264 char *map; 265 char *key; 266 unsigned long keylen; 267 { 268 ypreq_key ypkey; 269 ypresp_val *ypval; 270 CLIENT *clnt; 271 static char buf[YPMAXRECORD + 2]; 272 273 bzero((char *)buf, sizeof(buf)); 274 275 if ((clnt = clnt_create(server, YPPROG,YPVERS,"udp")) == NULL) { 276 yp_error("failed to create UDP handle: %s", 277 clnt_spcreateerror(server)); 278 return(0); 279 } 280 281 ypkey.domain = domain; 282 ypkey.map = map; 283 ypkey.key.keydat_len = keylen; 284 ypkey.key.keydat_val = key; 285 286 if ((ypval = ypproc_match_2(&ypkey, clnt)) == NULL) { 287 clnt_destroy(clnt); 288 yp_error("%s: %s", server, 289 clnt_sperror(clnt,"YPPROC_MATCH failed")); 290 return(0); 291 } 292 293 clnt_destroy(clnt); 294 295 if (ypval->stat != YP_TRUE) { 296 xdr_free(xdr_ypresp_val, (char *)ypval); 297 return(0); 298 } 299 300 xdr_free(xdr_ypresp_val, (char *)ypval); 301 302 return(1); 303 } 304