|
0
|
1 /* client.c - connect to a server */
|
|
|
2 #ifndef lint
|
|
12
|
3 static char ident[] = "@(#)$Id: client.c,v 1.3 2006/12/05 18:18:14 kono Exp $";
|
|
0
|
4 #endif /* lint */
|
|
|
5
|
|
|
6 #if defined(SYS5) && defined(AUX)
|
|
|
7 #define u_short ushort
|
|
|
8 #define u_long ulong
|
|
|
9 #endif
|
|
|
10
|
|
|
11
|
|
|
12 #if defined(BSD42) || defined(SOCKETS)
|
|
|
13 #include "../h/strings.h"
|
|
|
14 #include <stdio.h>
|
|
|
15 #include "mts.h"
|
|
|
16 #include <errno.h>
|
|
|
17 #include <sys/types.h>
|
|
|
18 #include <sys/socket.h>
|
|
|
19 #include <netinet/in.h>
|
|
|
20 #include <netdb.h>
|
|
|
21 #ifndef hpux
|
|
|
22 #include <arpa/inet.h>
|
|
|
23 #endif
|
|
|
24
|
|
|
25 #ifdef HESIOD
|
|
|
26 #include <hesiod.h>
|
|
|
27 #endif
|
|
|
28
|
|
|
29 #ifdef KPOP
|
|
|
30 #include <krb.h>
|
|
|
31 #include <ctype.h>
|
|
|
32
|
|
|
33 static CREDENTIALS cred;
|
|
|
34 static MSG_DAT msg_data;
|
|
|
35 static KTEXT ticket = (KTEXT)NULL;
|
|
|
36 static Key_schedule schedule;
|
|
|
37 #endif /* KPOP */
|
|
|
38
|
|
|
39 #define NOTOK (-1)
|
|
|
40 #define OK 0
|
|
|
41 #define DONE 1
|
|
|
42
|
|
|
43 #define TRUE 1
|
|
|
44 #define FALSE 0
|
|
|
45
|
|
|
46 #define OOPS1 (-2)
|
|
|
47 #define OOPS2 (-3)
|
|
|
48
|
|
|
49 #define MAXARGS 1000
|
|
|
50 #define MAXNETS 5
|
|
|
51 #define MAXHOSTS 25
|
|
|
52
|
|
|
53 /* */
|
|
|
54
|
|
|
55 #if !defined(BSD44) && !defined(__GNU_LIBRARY__)
|
|
|
56 extern int sys_nerr;
|
|
|
57 extern char *sys_errlist[];
|
|
|
58 #endif
|
|
|
59
|
|
|
60
|
|
|
61 struct addrent {
|
|
|
62 int a_addrtype; /* assumes AF_INET for inet_netof () */
|
|
|
63
|
|
|
64 union {
|
|
|
65 int un_net;
|
|
|
66 char un_addr[14];
|
|
|
67 } un;
|
|
|
68 #define a_net un.un_net
|
|
|
69 #define a_addr un.un_addr
|
|
|
70 };
|
|
|
71
|
|
|
72 static struct addrent *ne, *nz;
|
|
|
73 static struct addrent nets[MAXNETS];
|
|
|
74
|
|
|
75 static struct addrent *he, *hz;
|
|
|
76 static struct addrent hosts[MAXHOSTS];
|
|
|
77
|
|
|
78 #ifdef KPOP
|
|
|
79 char krb_realm[REALM_SZ];
|
|
|
80 char *PrincipalHostname();
|
|
|
81 static char *kservice; /* "pop" if using kpop */
|
|
|
82 #endif /* KPOP */
|
|
|
83
|
|
|
84 #ifdef __STDC__
|
|
|
85 static int rcaux (struct servent *, struct hostent *, int, char *);
|
|
|
86 static int getport (int, int, char *);
|
|
|
87 static int inet (struct hostent *, int);
|
|
|
88 #else
|
|
|
89 static int rcaux (), getport (), inet ();
|
|
|
90 #endif
|
|
|
91
|
|
|
92
|
|
|
93 #if defined(BIND) && !defined(h_addr)
|
|
|
94 #define h_addr h_addr_list[0]
|
|
|
95 #endif
|
|
|
96
|
|
|
97 #define inaddr_copy(hp,sin) \
|
|
|
98 bcopy ((hp) -> h_addr, (char *) &((sin) -> sin_addr), (hp) -> h_length)
|
|
|
99
|
|
|
100
|
|
|
101 struct hostent *gethostbystring ();
|
|
|
102
|
|
|
103
|
|
|
104 static int brkany ();
|
|
|
105 static char *getcpy (), **copyip (), **brkstring ();
|
|
|
106
|
|
|
107 /* */
|
|
|
108
|
|
|
109 int client (args, protocol, service, rproto, response)
|
|
|
110 char *args,
|
|
|
111 *protocol,
|
|
|
112 *service, /* "pop" or "pop/kpop" */
|
|
|
113 *response;
|
|
|
114 int rproto;
|
|
|
115 {
|
|
|
116 int sd;
|
|
|
117 register char **ap;
|
|
|
118 char *arguments[MAXARGS];
|
|
|
119 register struct hostent *hp;
|
|
|
120 #ifndef BIND
|
|
|
121 register struct netent *np;
|
|
|
122 #endif
|
|
|
123 register struct servent *sp;
|
|
|
124 #ifdef KPOP
|
|
|
125 char *cp;
|
|
|
126
|
|
|
127 if (cp = index (kservice = service, '/')) { /* "pop/kpop" */
|
|
|
128 *cp++ = '\0'; /* kservice = "pop" */
|
|
|
129 service = cp; /* service = "kpop" */
|
|
|
130 }
|
|
|
131 else
|
|
|
132 kservice = NULL; /* not using KERBEROS */
|
|
|
133 #endif /* KPOP */
|
|
|
134
|
|
|
135
|
|
|
136 if ((sp = getservbyname (service, protocol)) == NULL) {
|
|
|
137 #ifdef HESIOD
|
|
|
138 if ((sp = hes_getservbyname (service, protocol)) == NULL) {
|
|
|
139 (void) sprintf (response, "%s/%s: unknown service",
|
|
|
140 protocol, service);
|
|
|
141 return NOTOK;
|
|
|
142 }
|
|
|
143 #else
|
|
|
144 (void) sprintf (response, "%s/%s: unknown service", protocol, service);
|
|
|
145 return NOTOK;
|
|
|
146 #endif
|
|
|
147 }
|
|
|
148
|
|
|
149 ap = arguments;
|
|
|
150 if (args != NULL && *args != 0)
|
|
|
151 ap = copyip (brkstring (getcpy (args), " ", "\n"), ap);
|
|
|
152 else
|
|
|
153 if (servers != NULL && *servers != 0)
|
|
|
154 ap = copyip (brkstring (getcpy (servers), " ", "\n"), ap);
|
|
|
155 if (ap == arguments) {
|
|
|
156 *ap++ = getcpy ("localhost");
|
|
|
157 *ap = NULL;
|
|
|
158 }
|
|
|
159
|
|
|
160 nz = (ne = nets) + sizeof nets / sizeof nets[0];
|
|
|
161 hz = (he = hosts) + sizeof hosts / sizeof hosts[0];
|
|
|
162
|
|
|
163 for (ap = arguments; *ap; ap++) {
|
|
|
164 if (**ap == '\01') {
|
|
|
165 #if !defined(BIND) && !defined(__CYGWIN32__)
|
|
|
166 if (np = getnetbyname (*ap + 1)) {
|
|
|
167 sethostent (1);
|
|
|
168 while (hp = gethostent ())
|
|
|
169 if (np -> n_addrtype == hp -> h_addrtype
|
|
|
170 && inet (hp, np -> n_net)) {
|
|
|
171 switch (sd = rcaux (sp, hp, rproto, response)) {
|
|
|
172 case NOTOK:
|
|
|
173 continue;
|
|
|
174 case OOPS1:
|
|
|
175 break;
|
|
|
176 case OOPS2:
|
|
|
177 return NOTOK;
|
|
|
178
|
|
|
179 default:
|
|
|
180 return sd;
|
|
|
181 }
|
|
|
182 break;
|
|
|
183 }
|
|
|
184 }
|
|
|
185 #endif
|
|
|
186 continue;
|
|
|
187 }
|
|
|
188
|
|
|
189 if (hp = gethostbystring (*ap)) {
|
|
|
190 switch (sd = rcaux (sp, hp, rproto, response)) {
|
|
|
191 case NOTOK:
|
|
|
192 case OOPS1:
|
|
|
193 break;
|
|
|
194 case OOPS2:
|
|
|
195 return NOTOK;
|
|
|
196
|
|
|
197 default:
|
|
|
198 return sd;
|
|
|
199 }
|
|
|
200 continue;
|
|
|
201 }
|
|
|
202 }
|
|
|
203
|
|
|
204 (void) strcpy (response, "no servers available");
|
|
|
205 return NOTOK;
|
|
|
206 }
|
|
|
207
|
|
|
208 /* */
|
|
|
209
|
|
|
210 static int rcaux (sp, hp, rproto, response)
|
|
|
211 register struct servent *sp;
|
|
|
212 register struct hostent *hp;
|
|
|
213 int rproto;
|
|
|
214 register char *response;
|
|
|
215 {
|
|
|
216 int sd;
|
|
|
217 struct in_addr in;
|
|
|
218 register struct addrent *ap;
|
|
|
219 struct sockaddr_in in_socket;
|
|
|
220 register struct sockaddr_in *isock = &in_socket;
|
|
|
221 #ifdef KPOP
|
|
|
222 int rem;
|
|
|
223 #endif /* KPOP */
|
|
|
224
|
|
|
225 for (ap = nets; ap < ne; ap++)
|
|
|
226 if (ap -> a_addrtype == hp -> h_addrtype && inet (hp, ap -> a_net))
|
|
|
227 return NOTOK;
|
|
|
228
|
|
|
229 for (ap = hosts; ap < he; ap++)
|
|
|
230 if (ap -> a_addrtype == hp -> h_addrtype
|
|
|
231 && bcmp (ap -> a_addr, hp -> h_addr, hp -> h_length) == 0)
|
|
|
232 return NOTOK;
|
|
|
233
|
|
|
234 if ((sd = getport (rproto, hp -> h_addrtype, response)) == NOTOK)
|
|
|
235 return OOPS2;
|
|
|
236
|
|
|
237 bzero ((char *) isock, sizeof *isock);
|
|
|
238 isock -> sin_family = hp -> h_addrtype;
|
|
|
239 inaddr_copy (hp, isock);
|
|
|
240 isock -> sin_port = sp -> s_port;
|
|
|
241
|
|
|
242 if (connect (sd, (struct sockaddr *) isock, sizeof *isock) == NOTOK)
|
|
|
243 switch (errno) {
|
|
|
244 case ENETDOWN:
|
|
|
245 case ENETUNREACH:
|
|
|
246 (void) close (sd);
|
|
|
247 if (ne < nz) {
|
|
|
248 ne -> a_addrtype = hp -> h_addrtype;
|
|
|
249 bcopy (hp -> h_addr, (char *) &in, sizeof in);
|
|
|
250 ne -> a_net = inet_netof (in);
|
|
|
251 ne++;
|
|
|
252 }
|
|
|
253 return OOPS1;
|
|
|
254
|
|
|
255 case ETIMEDOUT:
|
|
|
256 case ECONNREFUSED:
|
|
|
257 default:
|
|
|
258 (void) close (sd);
|
|
|
259 if (he < hz) {
|
|
|
260 he -> a_addrtype = hp -> h_addrtype;
|
|
|
261 bcopy (hp -> h_addr, he -> a_addr, hp -> h_length);
|
|
|
262 he++;
|
|
|
263 }
|
|
|
264 return NOTOK;
|
|
|
265 }
|
|
|
266
|
|
|
267 #ifdef KPOP
|
|
|
268 if (kservice) { /* "pop" */
|
|
|
269 ticket = (KTEXT)malloc( sizeof(KTEXT_ST) );
|
|
|
270 rem = krb_sendauth(0L, sd, ticket, kservice, hp->h_name,
|
|
|
271 (char *) krb_realmofhost(hp->h_name),
|
|
|
272 (unsigned long)0, &msg_data, &cred, schedule,
|
|
|
273 (struct sockaddr_in *)NULL,
|
|
|
274 (struct sockaddr_in *)NULL,
|
|
|
275 "KPOPV0.1");
|
|
|
276 if (rem != KSUCCESS) {
|
|
|
277 close(sd);
|
|
|
278 (void) strcpy(response, "Post office refused connection: ");
|
|
|
279 (void) strcat(response, krb_err_txt[rem]);
|
|
|
280 return OOPS2;
|
|
|
281 }
|
|
|
282 }
|
|
|
283 #endif /* KPOP */
|
|
|
284
|
|
|
285 return sd;
|
|
|
286 }
|
|
|
287
|
|
|
288 /* */
|
|
|
289
|
|
|
290 static int getport (rproto, addrtype, response)
|
|
|
291 int rproto,
|
|
|
292 addrtype;
|
|
|
293 register char *response;
|
|
|
294 {
|
|
|
295 int sd,
|
|
|
296 port;
|
|
|
297 struct sockaddr_in in_socket,
|
|
|
298 *isock = &in_socket;
|
|
|
299
|
|
|
300 if (rproto && addrtype != AF_INET) {
|
|
|
301 (void) sprintf (response, "reserved ports not supported for af=%d",
|
|
|
302 addrtype);
|
|
|
303 errno = ENOPROTOOPT;
|
|
|
304 return NOTOK;
|
|
|
305 }
|
|
|
306
|
|
|
307 if ((sd = socket (AF_INET, SOCK_STREAM, 0)) == NOTOK) {
|
|
|
308 (void) sprintf (response, "unable to create socket: %s",
|
|
|
309 errno > 0 && errno < sys_nerr ? sys_errlist[errno]
|
|
|
310 : "unknown error");
|
|
|
311 return NOTOK;
|
|
|
312 }
|
|
|
313 #ifdef KPOP
|
|
|
314 if (kservice) /* "pop" */
|
|
|
315 return(sd);
|
|
|
316 #endif /* KPOP */
|
|
|
317 if (!rproto)
|
|
|
318 return sd;
|
|
|
319
|
|
|
320 bzero ((char *) isock, sizeof *isock);
|
|
|
321 isock -> sin_family = addrtype;
|
|
|
322 for (port = IPPORT_RESERVED - 1;;) {
|
|
|
323 isock -> sin_port = htons ((u_short) port);
|
|
|
324 if (bind (sd, (struct sockaddr *) isock, sizeof *isock) != NOTOK)
|
|
|
325 return sd;
|
|
|
326
|
|
|
327 switch (errno) {
|
|
|
328 case EADDRINUSE:
|
|
|
329 case EADDRNOTAVAIL:
|
|
|
330 if (--port <= IPPORT_RESERVED / 2) {
|
|
|
331 (void) strcpy (response, "ports available");
|
|
|
332 return NOTOK;
|
|
|
333 }
|
|
|
334 break;
|
|
|
335
|
|
|
336 default:
|
|
|
337 (void) sprintf (response, "unable to bind socket: %s",
|
|
|
338 errno > 0 && errno < sys_nerr ? sys_errlist[errno]
|
|
|
339 : "unknown error");
|
|
|
340 return NOTOK;
|
|
|
341 }
|
|
|
342 }
|
|
|
343 }
|
|
|
344
|
|
|
345 /* */
|
|
|
346
|
|
|
347 static int inet (hp, net)
|
|
|
348 register struct hostent *hp;
|
|
|
349 int net;
|
|
|
350 {
|
|
|
351 struct in_addr in;
|
|
|
352
|
|
|
353 bcopy (hp -> h_addr, (char *) &in, sizeof in);
|
|
|
354 return (inet_netof (in) == net);
|
|
|
355 }
|
|
|
356
|
|
|
357 /* */
|
|
|
358
|
|
|
359 /* taken from ISODE's compat/internet.c */
|
|
|
360
|
|
|
361 #if !defined(SOLARIS) && !defined(linux) && !defined(__bsdi__) && \
|
|
|
362 !defined(OSF1) && !defined(__osf__) && !defined(__FreeBSD__) && \
|
|
2
|
363 !defined(__NetBSD__) && !defined(__APPLE__)
|
|
0
|
364 #ifndef DG
|
|
|
365 #ifndef __alpha
|
|
|
366 u_long inet_addr ();
|
|
|
367 #else
|
|
|
368 u_int inet_addr ();
|
|
|
369 #endif
|
|
|
370 #else
|
|
|
371 struct in_addr inet_addr ();
|
|
|
372 #endif
|
|
|
373 #endif
|
|
|
374
|
|
|
375 static char *empty = NULL;
|
|
|
376 #ifdef h_addr
|
|
|
377 static char *addrs[2] = { NULL };
|
|
|
378 #endif
|
|
|
379 struct hostent *mh_gethostbyname();
|
|
|
380
|
|
|
381 struct hostent *gethostbystring (s)
|
|
|
382 char *s;
|
|
|
383 {
|
|
|
384 register struct hostent *h;
|
|
|
385 #ifndef DG
|
|
|
386 #ifndef __alpha
|
|
|
387 static u_long iaddr;
|
|
|
388 #else
|
|
|
389 static u_int iaddr;
|
|
|
390 #endif
|
|
|
391 #else
|
|
|
392 static struct in_addr iaddr;
|
|
|
393 #endif
|
|
|
394 static struct hostent hs;
|
|
|
395
|
|
|
396 iaddr = inet_addr (s);
|
|
|
397 #ifndef DG
|
|
|
398 if ((int)iaddr == NOTOK && strcmp (s, "255.255.255.255"))
|
|
|
399 #else
|
|
|
400 if (iaddr.s_addr == NOTOK && strcmp (s, "255.255.255.255"))
|
|
|
401 #endif
|
|
|
402 return mh_gethostbyname (s);
|
|
|
403
|
|
|
404 h = &hs;
|
|
|
405 h -> h_name = s;
|
|
|
406 h -> h_aliases = ∅
|
|
|
407 h -> h_addrtype = AF_INET;
|
|
|
408 h -> h_length = sizeof (iaddr);
|
|
|
409 #ifdef h_addr
|
|
|
410 h -> h_addr_list = addrs;
|
|
|
411 bzero ((char *) addrs, sizeof addrs);
|
|
|
412 #endif
|
|
|
413 h -> h_addr = (char *) &iaddr;
|
|
|
414
|
|
|
415 return h;
|
|
|
416 }
|
|
|
417
|
|
|
418 /* */
|
|
|
419
|
|
|
420 /* static copies of three MH subroutines... (sigh) */
|
|
|
421
|
|
|
422 static char *broken[MAXARGS + 1];
|
|
|
423
|
|
|
424
|
|
|
425 static char **brkstring (strg, brksep, brkterm)
|
|
|
426 register char *strg;
|
|
|
427 register char *brksep,
|
|
|
428 *brkterm;
|
|
|
429 {
|
|
|
430 register int bi;
|
|
|
431 register char c,
|
|
|
432 *sp;
|
|
|
433
|
|
|
434 sp = strg;
|
|
|
435
|
|
|
436 for (bi = 0; bi < MAXARGS; bi++) {
|
|
|
437 while (brkany (c = *sp, brksep))
|
|
|
438 *sp++ = 0;
|
|
|
439 if (!c || brkany (c, brkterm)) {
|
|
|
440 *sp = 0;
|
|
|
441 broken[bi] = 0;
|
|
|
442 return broken;
|
|
|
443 }
|
|
|
444
|
|
|
445 broken[bi] = sp;
|
|
|
446 while ((c = *++sp) && !brkany (c, brksep) && !brkany (c, brkterm))
|
|
|
447 continue;
|
|
|
448 }
|
|
|
449 broken[MAXARGS] = 0;
|
|
|
450
|
|
|
451 return broken;
|
|
|
452 }
|
|
|
453
|
|
|
454
|
|
|
455 static brkany (chr, strg)
|
|
|
456 register char chr,
|
|
|
457 *strg;
|
|
|
458 {
|
|
|
459 register char *sp;
|
|
|
460
|
|
|
461 if (strg)
|
|
|
462 for (sp = strg; *sp; sp++)
|
|
|
463 if (chr == *sp)
|
|
|
464 return 1;
|
|
|
465 return 0;
|
|
|
466 }
|
|
|
467
|
|
|
468
|
|
|
469 static char **copyip (p, q)
|
|
|
470 register char **p,
|
|
|
471 **q;
|
|
|
472 {
|
|
|
473 while (*p)
|
|
|
474 *q++ = *p++;
|
|
|
475 *q = 0;
|
|
|
476
|
|
|
477 return q;
|
|
|
478 }
|
|
|
479
|
|
|
480
|
|
|
481 static char *getcpy (str)
|
|
|
482 register char *str;
|
|
|
483 {
|
|
|
484 register char *cp;
|
|
|
485
|
|
|
486 if ((cp = malloc ((unsigned) (strlen (str) + 1))) == NULL)
|
|
|
487 return NULL;
|
|
|
488
|
|
|
489 (void) strcpy (cp, str);
|
|
|
490 return cp;
|
|
|
491 }
|
|
|
492 #endif /* BSD42 or SOCKETS */
|
