Annotation of embedaddon/mpd/src/util.c, revision 1.1.1.1
1.1 misho 1:
2: /*
3: * util.c
4: *
5: * Written by Archie Cobbs <archie@freebsd.org>
6: * Copyright (c) 1995-1999 Whistle Communications, Inc. All rights reserved.
7: * See ``COPYRIGHT.whistle''
8: */
9:
10: #include "ppp.h"
11: #include "util.h"
12: #include <termios.h>
13:
14: #include <netdb.h>
15: #include <tcpd.h>
16: #include <sys/wait.h>
17: #include <sys/sysctl.h>
18: #include <net/route.h>
19: #include <netinet/if_ether.h>
20:
21: /*
22: * DEFINITIONS
23: */
24:
25: #define MAX_FILENAME 1000
26: #define MAX_LINE_ARGS 50
27: #define BIG_LINE_SIZE 1000
28: #define MAX_OPEN_DELAY 2
29: #define MAX_LOCK_ATTEMPTS 30
30:
31: /*
32: * INTERNAL VARIABLES
33: */
34:
35: static const u_int16_t Crc16Table[256] = {
36: /* 00 */ 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
37: /* 08 */ 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
38: /* 10 */ 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
39: /* 18 */ 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
40: /* 20 */ 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
41: /* 28 */ 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
42: /* 30 */ 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
43: /* 38 */ 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
44: /* 40 */ 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
45: /* 48 */ 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
46: /* 50 */ 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
47: /* 58 */ 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
48: /* 60 */ 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
49: /* 68 */ 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
50: /* 70 */ 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
51: /* 78 */ 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
52: /* 80 */ 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
53: /* 88 */ 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
54: /* 90 */ 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
55: /* 98 */ 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
56: /* a0 */ 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
57: /* a8 */ 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
58: /* b0 */ 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
59: /* b8 */ 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
60: /* c0 */ 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
61: /* c8 */ 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
62: /* d0 */ 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
63: /* d8 */ 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
64: /* e0 */ 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
65: /* e8 */ 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
66: /* f0 */ 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
67: /* f8 */ 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
68: };
69:
70: static FILE *lockFp = NULL;
71:
72: /*
73: * INTERNAL FUNCTIONS
74: */
75:
76: static int UuLock(const char *devname);
77: static int UuUnlock(const char *devname);
78:
79: static void Escape(char *line);
80: static char *ReadLine(FILE *fp, int *lineNum, char *result, int resultsize);
81:
82: static char HexVal(char c);
83:
84: static void IndexConfFile(FILE *fp, struct configfile **cf);
85:
86: struct configfiles *ConfigFilesIndex=NULL;
87:
88: #undef isspace
89: #define isspace(c) (((c)==' '||(c)=='\t'||(c)=='\n'||(c)=='\r')?1:0)
90:
91: /*
92: * LengthenArray()
93: */
94:
95: void
96: LengthenArray(void *array, size_t esize, int *alenp, const char *type)
97: {
98: void **const arrayp = (void **)array;
99: void *newa;
100:
101: newa = Malloc(type, (*alenp + 1) * esize);
102: if (*arrayp != NULL) {
103: memcpy(newa, *arrayp, *alenp * esize);
104: Freee(*arrayp);
105: }
106: *arrayp = newa;
107: (*alenp)++;
108: }
109:
110: /*
111: * ExecCmd()
112: */
113:
114: int
115: ExecCmd(int log, const char *label, const char *fmt, ...)
116: {
117: int rtn;
118: char cmd[BIG_LINE_SIZE];
119: char cmdn[BIG_LINE_SIZE];
120: va_list ap;
121:
122: va_start(ap, fmt);
123: vsnprintf(cmd, sizeof(cmd), fmt, ap);
124: va_end(ap);
125: strcpy(cmdn, cmd);
126:
127: /* Log command on the console */
128:
129: Log(log, ("[%s] system: %s", label, cmd));
130:
131: /* Hide any stdout output of command */
132:
133: snprintf(cmdn + strlen(cmdn), sizeof(cmdn) - strlen(cmdn), " >/dev/null 2>&1");
134:
135: /* Do command */
136:
137: if ((rtn = system(cmdn)))
138: Log(log|LG_ERR, ("[%s] system: command \"%s\" returned %d", label, cmd, rtn));
139:
140: /* Return command's return value */
141:
142: return(rtn);
143: }
144:
145: /*
146: * ExecCmdNosh()
147: */
148:
149: int
150: ExecCmdNosh(int log, const char *label, const char *fmt, ...)
151: {
152: int rtn;
153: char cmd[BIG_LINE_SIZE];
154: char *cmdp = &(cmd[0]);
155: char *argv[256];
156: char **arg;
157: va_list ap;
158:
159: pid_t pid, savedpid;
160: int pstat;
161: struct sigaction ign, intact, quitact;
162: sigset_t newsigblock, oldsigblock;
163:
164: va_start(ap, fmt);
165: vsnprintf(cmd, sizeof(cmd), fmt, ap);
166: va_end(ap);
167:
168: /* Log command on the console */
169: Log(log, ("[%s] exec: %s", label, cmd));
170:
171: /* Parce args */
172: for (arg = &argv[0]; (*arg = strsep(&cmdp, " \t")) != NULL;) {
173: if (**arg != '\0') {
174: if (++arg >= &argv[255])
175: break;
176: }
177: }
178: *arg = NULL;
179:
180: /* Do command */
181:
182: /*
183: * Ignore SIGINT and SIGQUIT, block SIGCHLD. Remember to save
184: * existing signal dispositions.
185: */
186: ign.sa_handler = SIG_IGN;
187: (void)sigemptyset(&ign.sa_mask);
188: ign.sa_flags = 0;
189: (void)sigaction(SIGINT, &ign, &intact);
190: (void)sigaction(SIGQUIT, &ign, &quitact);
191: (void)sigemptyset(&newsigblock);
192: (void)sigaddset(&newsigblock, SIGCHLD);
193: (void)sigprocmask(SIG_BLOCK, &newsigblock, &oldsigblock);
194: switch(pid = fork()) {
195: case -1: /* error */
196: break;
197: case 0: /* child */
198: /*
199: * Restore original signal dispositions and exec the command.
200: */
201: (void)sigaction(SIGINT, &intact, NULL);
202: (void)sigaction(SIGQUIT, &quitact, NULL);
203: (void)sigprocmask(SIG_SETMASK, &oldsigblock, NULL);
204: close(1);
205: open("/dev/null", O_WRONLY);
206: close(2);
207: open("/dev/null", O_WRONLY);
208: execv(argv[0], argv);
209: exit(127);
210: default: /* parent */
211: savedpid = pid;
212: do {
213: pid = wait4(savedpid, &pstat, 0, (struct rusage *)0);
214: } while (pid == -1 && errno == EINTR);
215: break;
216: }
217: (void)sigaction(SIGINT, &intact, NULL);
218: (void)sigaction(SIGQUIT, &quitact, NULL);
219: (void)sigprocmask(SIG_SETMASK, &oldsigblock, NULL);
220:
221: rtn = (pid == -1 ? -1 : pstat);
222:
223: if (rtn)
224: Log(log|LG_ERR, ("[%s] system: command \"%s\" returned %d", label, cmd, rtn));
225:
226: /* Return command's return value */
227: return(rtn);
228: }
229:
230: /*
231: * ParseLine()
232: *
233: * Parse arguments, respecting double quotes and backslash escapes.
234: * Returns number of arguments, at most "max_args". This destroys
235: * the original line. The arguments returned are Malloc()'d strings
236: * which must be freed by the caller using FreeArgs().
237: */
238:
239: int
240: ParseLine(char *line, char *av[], int max_args, int copy)
241: {
242: int ac;
243: char *s, *arg;
244:
245: /* Get args one at a time */
246:
247: for (ac = 0; ac < max_args; ac++)
248: {
249:
250: /* Skip white space */
251:
252: while (*line && isspace(*line))
253: line++;
254:
255: /* Done? */
256:
257: if (*line == 0)
258: break;
259:
260: /* Get normal or quoted arg */
261:
262: if (*line == '"')
263: {
264:
265: /* Stop only upon matching quote or NUL */
266:
267: for (arg = ++line; *line; line++)
268: if (*line == '"')
269: {
270: *line++ = 0;
271: break;
272: }
273: else if (*line == '\\' && line[1] != 0)
274: {
275: strcpy(line, line + 1);
276: Escape(line);
277: }
278: }
279: else
280: {
281:
282: /* NUL terminate this argument at first white space */
283:
284: for (arg = line; *line && !isspace(*line); line++);
285: if (*line)
286: *line++ = 0;
287:
288: /* Convert characters */
289:
290: for (s = arg; *s; s++)
291: if (*s == '\\')
292: {
293: strcpy(s, s + 1);
294: Escape(s);
295: }
296: }
297:
298: /* Make a copy of this arg */
299:
300: if (copy) {
301: strcpy(av[ac] = Malloc(MB_CMD, strlen(arg) + 1), arg);
302: }
303: else
304: av[ac] = arg;
305: }
306:
307: #if 0
308: {
309: int k;
310:
311: printf("ParseLine: %d args:\n", ac);
312: for (k = 0; k < ac; k++)
313: printf(" [%2d] \"%s\"\n", k, av[k]);
314: }
315: #endif
316:
317: return(ac);
318: }
319:
320: /*
321: * FreeArgs()
322: */
323:
324: void
325: FreeArgs(int ac, char *av[])
326: {
327: while (ac > 0)
328: Freee(av[--ac]);
329: }
330:
331: /*
332: * Escape()
333: *
334: * Give a string, interpret the beginning characters as an escape
335: * code and return with that code converted.
336: */
337:
338: static void
339: Escape(char *line)
340: {
341: int x, k;
342: char *s = line;
343:
344: switch (*line)
345: {
346: case 't': *s = '\t'; return;
347: case 'n': *s = '\n'; return;
348: case 'r': *s = '\r'; return;
349: case 's': *s = ' '; return;
350: case '"': *s = '"'; return;
351: case '0': case '1': case '2': case '3':
352: case '4': case '5': case '6': case '7':
353: for (x = k = 0; k < 3 && *s >= '0' && *s <= '7'; s++)
354: x = (x << 3) + (*s - '0');
355: *--s = x;
356: break;
357: case 'x':
358: for (s++, x = k = 0; k < 2 && isxdigit(*s); s++)
359: x = (x << 4) + (isdigit(*s) ? (*s - '0') : (tolower(*s) - 'a' + 10));
360: *--s = x;
361: break;
362: default:
363: return;
364: }
365: strcpy(line, s);
366: }
367:
368: /*
369: * ReadFile()
370: *
371: * Read the commands specified for the target in the specified
372: * file, which can be found in the PATH_CONF_DIR directory.
373: * Returns negative if the file or target was not found.
374: */
375:
376: int
377: ReadFile(const char *filename, const char *target,
378: int (*func)(Context ctx, int ac, char *av[], const char *file, int line), Context ctx)
379: {
380: FILE *fp;
381: int ac;
382: char *av[MAX_LINE_ARGS];
383: char *line;
384: char buf[BIG_LINE_SIZE];
385: struct configfile *cf;
386: int lineNum;
387:
388: /* Open file */
389:
390: if ((fp = OpenConfFile(filename, &cf)) == NULL)
391: return(-1);
392:
393: /* Find label */
394:
395: if (SeekToLabel(fp, target, &lineNum, cf) < 0) {
396: fclose(fp);
397: return(-1);
398: }
399:
400: /* Execute command list */
401:
402: while ((line = ReadFullLine(fp, &lineNum, buf, sizeof(buf))) != NULL)
403: {
404: if (!isspace(*line))
405: {
406: break;
407: }
408: ac = ParseLine(line, av, sizeof(av) / sizeof(*av), 0);
409: (*func)(ctx, ac, av, filename, lineNum);
410: }
411:
412: /* Done */
413:
414: fclose(fp);
415: return(0);
416: }
417:
418: /*
419: * IndexConfFile()
420: *
421: * Scan config file for labels
422: */
423:
424: static void
425: IndexConfFile(FILE *fp, struct configfile **cf)
426: {
427: char *s, *line;
428: char buf[BIG_LINE_SIZE];
429: struct configfile **tmp;
430: int lineNum;
431:
432: /* Start at beginning */
433:
434: rewind(fp);
435: lineNum = 0;
436:
437: tmp=cf;
438:
439: /* Find label */
440:
441: while ((line = ReadFullLine(fp, &lineNum, buf, sizeof(buf))) != NULL)
442: {
443: if (isspace(*line))
444: continue;
445: if ((s = strtok(line, " \t\f:"))) {
446: (*tmp)=Malloc(MB_CMDL, sizeof(struct configfile));
447: (*tmp)->label=strcpy(Malloc(MB_CMDL, strlen(s)+1),s);
448: (*tmp)->linenum=lineNum;
449: (*tmp)->seek=ftello(fp);
450: tmp=&((*tmp)->next);
451: }
452: }
453: }
454:
455: /*
456: * SeekToLabel()
457: *
458: * Find a label in file and position file pointer just after it
459: */
460:
461: int
462: SeekToLabel(FILE *fp, const char *label, int *lineNum, struct configfile *cf)
463: {
464: char *s, *line;
465: char buf[BIG_LINE_SIZE];
466: struct configfile *tmp;
467:
468: if (cf) { /* Trying to use index */
469: tmp=cf;
470: while (tmp && strcmp(tmp->label,label)) {
471: tmp=tmp->next;
472: }
473: if (tmp) {
474: fseeko(fp,tmp->seek, SEEK_SET);
475: if (lineNum)
476: *lineNum=tmp->linenum;
477: return(0);
478: }
479: } else { /* There are no index */
480:
481: /* Start at beginning */
482: rewind(fp);
483: if (lineNum)
484: *lineNum = 0;
485:
486: /* Find label */
487:
488: while ((line = ReadFullLine(fp, lineNum, buf, sizeof(buf))) != NULL)
489: {
490: if (isspace(*line))
491: continue;
492: if ((s = strtok(line, " \t\f:")) && !strcmp(s, label))
493: return(0);
494: }
495: }
496:
497: /* Not found */
498: Log(LG_ERR, ("Label '%s' not found", label));
499: return(-1);
500: }
501:
502: /*
503: * OpenConfFile()
504: *
505: * Open a configuration file
506: */
507:
508: FILE *
509: OpenConfFile(const char *name, struct configfile **cf)
510: {
511: char pathname[MAX_FILENAME];
512: FILE *fp;
513: struct configfiles **tmp;
514:
515: /* Build full pathname */
516: if (name[0] == '/')
517: snprintf(pathname, sizeof(pathname), "%s", name);
518: else
519: snprintf(pathname, sizeof(pathname), "%s/%s", gConfDirectory, name);
520:
521: /* Open file */
522:
523: if ((fp = fopen(pathname, "r")) == NULL)
524: {
525: Perror("%s: Can't open file '%s'", __FUNCTION__, pathname);
526: return(NULL);
527: }
528: (void) fcntl(fileno(fp), F_SETFD, 1);
529:
530: if (cf) {
531: tmp=&ConfigFilesIndex;
532: while ((*tmp) && strcmp((*tmp)->filename,name)) {
533: tmp=&((*tmp)->next);
534: }
535: if (!(*tmp)) {
536: (*tmp) = Malloc(MB_CMD, sizeof(struct configfiles));
537: (*tmp)->filename = strcpy(Malloc(MB_CMD, strlen(name)+1),name);
538: (*tmp)->sections = NULL;
539: (*tmp)->next = NULL;
540: IndexConfFile(fp, &((*tmp)->sections));
541: }
542: *cf=(*tmp)->sections;
543: }
544:
545: return(fp);
546: }
547:
548: /*
549: * ReadFullLine()
550: *
551: * Read a full line, respecting backslash continuations.
552: * Returns pointer to Malloc'd storage, which must be Freee'd
553: */
554:
555: char *
556: ReadFullLine(FILE *fp, int *lineNum, char *result, int resultsize)
557: {
558: int len, linelen, resultlinesize, continuation;
559: char line[BIG_LINE_SIZE];
560: char real_line[BIG_LINE_SIZE];
561: char *resultline;
562:
563: if (result!=NULL && resultsize>0) {
564: resultline=result;
565: resultlinesize=resultsize;
566: } else {
567: resultline=line;
568: resultlinesize=sizeof(line);
569: }
570:
571: resultline[0] = 0;
572: linelen = 0;
573: continuation = TRUE;
574:
575: while ( continuation )
576: {
577:
578: /* Get next real line */
579:
580: if (ReadLine(fp, lineNum, real_line, sizeof(real_line)) == NULL) {
581: if (*resultline)
582: break;
583: else
584: return(NULL);
585: }
586:
587: /* Strip trailing white space, detect backslash */
588:
589: for (len = strlen(real_line);
590: len > 0 && isspace(real_line[len - 1]);
591: len--) {};
592: real_line[len] = 0;
593:
594: if ((continuation = (len && real_line[len - 1] == '\\')))
595: real_line[len - 1] = ' ';
596:
597: /* Append real line to what we've got so far */
598:
599: strlcpy(resultline + linelen, real_line, resultlinesize - linelen);
600: linelen += len;
601: if (linelen > sizeof(line) - 1)
602: linelen = sizeof(line) - 1;
603: }
604:
605: /* Report any overflow */
606:
607: if (linelen >= sizeof(line) - 1)
608: Log(LG_ERR, ("warning: line too long, truncated"));
609:
610: /* Copy line and return */
611:
612: if (result!=NULL && resultsize>0)
613: return resultline;
614: else
615: return strcpy(Malloc(MB_CMD, linelen + 1), resultline);
616: }
617:
618: /*
619: * ReadLine()
620: *
621: * Read a line, skipping blank lines & comments. A comment
622: * is a line whose first non-white-space character is a hash.
623: */
624:
625: static char *
626: ReadLine(FILE *fp, int *lineNum, char *result, int resultsize)
627: {
628: int empty;
629: char *s;
630: int ch;
631:
632: if ((!result) || (resultsize <= 0))
633: return (NULL);
634:
635: /* Get first non-empty, non-commented line */
636: empty = TRUE;
637: while ( empty ) {
638:
639: /* Read next line from file */
640: if ((fgets(result, resultsize, fp)) == NULL)
641: return(NULL);
642: if (lineNum)
643: (*lineNum)++;
644:
645: /* Truncate long lines */
646: if (strlen(result) > (resultsize - 2)) {
647: Log(LG_ERR, ("warning: line too long, truncated"));
648: while ((ch = getc(fp)) != EOF && ch != '\n');
649: }
650:
651: /* Ignore comments */
652: s = result + strspn(result, " \t");
653: if (*s == '#') {
654: *s = 0;
655: } else {
656: /* Is this line empty? */
657: for ( ; *s; s++) {
658: if (!isspace(*s)) {
659: empty = FALSE;
660: break;
661: }
662: }
663: }
664: }
665:
666: return(result);
667: }
668:
669: /*
670: * OpenSerialDevice()
671: *
672: * Open and configure a serial device. Call ExclusiveCloseDevice()
673: * to close a file descriptor returned by this function.
674: */
675:
676: int
677: OpenSerialDevice(const char *label, const char *path, int baudrate)
678: {
679: struct termios attr;
680: int fd;
681:
682: /* Open & lock serial port */
683:
684: if ((fd = ExclusiveOpenDevice(label, path)) < 0)
685: return(-1);
686:
687: /* Set non-blocking I/O */
688:
689: if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0)
690: {
691: Perror("[%s] can't set \"%s\" to non-blocking", label, path);
692: goto failed;
693: }
694:
695: /* Set serial port raw mode, baud rate, hardware flow control, etc. */
696:
697: if (tcgetattr(fd, &attr) < 0)
698: {
699: Perror("[%s] can't tcgetattr \"%s\"", label, path);
700: goto failed;
701: }
702:
703: cfmakeraw(&attr);
704:
705: attr.c_cflag &= ~(CSIZE|PARENB|PARODD);
706: attr.c_cflag |= (CS8|CREAD|CLOCAL|HUPCL|CCTS_OFLOW|CRTS_IFLOW);
707: attr.c_iflag &= ~(IXANY|IMAXBEL|ISTRIP|IXON|IXOFF|BRKINT|ICRNL|INLCR);
708: attr.c_iflag |= (IGNBRK|IGNPAR);
709: attr.c_oflag &= ~OPOST;
710: attr.c_lflag = 0;
711:
712: cfsetspeed(&attr, (speed_t) baudrate);
713:
714: if (tcsetattr(fd, TCSANOW, &attr) < 0)
715: {
716: Perror("[%s] can't tcsetattr \"%s\"", label, path);
717: failed:
718: ExclusiveCloseDevice(label, fd, path);
719: return(-1);
720: }
721:
722: /* OK */
723:
724: return(fd);
725: }
726:
727: /*
728: * ExclusiveOpenDevice()
729: */
730:
731: int
732: ExclusiveOpenDevice(const char *label, const char *pathname)
733: {
734: int fd, locked = FALSE;
735: const char *ttyname = NULL;
736: time_t startTime;
737:
738: /* Lock device UUCP style, if it resides in /dev */
739:
740: if (!strncmp(pathname, "/dev/", 5))
741: {
742: ttyname = pathname + 5;
743: if (UuLock(ttyname) < 0)
744: {
745: Log(LG_ERR, ("[%s] can't lock device %s", label, ttyname));
746: return(-1);
747: }
748: locked = TRUE;
749: }
750:
751: /* Open it, but give up after so many interruptions */
752:
753: for (startTime = time(NULL);
754: (fd = open(pathname, O_RDWR, 0)) < 0
755: && time(NULL) < startTime + MAX_OPEN_DELAY; )
756: if (errno != EINTR)
757: {
758: Perror("[%s] can't open %s", label, pathname);
759: if (locked)
760: UuUnlock(ttyname);
761: return(-1);
762: }
763:
764: /* Did we succeed? */
765:
766: if (fd < 0)
767: {
768: Log(LG_ERR, ("[%s] can't open %s after %d secs",
769: label, pathname, MAX_OPEN_DELAY));
770: if (locked)
771: UuUnlock(ttyname);
772: return(-1);
773: }
774: (void) fcntl(fd, F_SETFD, 1);
775:
776: /* Done */
777:
778: return(fd);
779: }
780:
781: /*
782: * ExclusiveCloseDevice()
783: */
784:
785: void
786: ExclusiveCloseDevice(const char *label, int fd, const char *pathname)
787: {
788: int rtn = -1;
789: const char *ttyname;
790: time_t startTime;
791:
792: /* Close file(s) */
793:
794: for (startTime = time(NULL);
795: time(NULL) < startTime + MAX_OPEN_DELAY && (rtn = close(fd)) < 0; )
796: if (errno != EINTR)
797: {
798: Perror("[%s] can't close %s", label, pathname);
799: break;
800: }
801:
802: /* Did we succeed? */
803:
804: if ((rtn < 0) && (errno == EINTR))
805: {
806: Log(LG_ERR, ("[%s] can't close %s after %d secs",
807: label, pathname, MAX_OPEN_DELAY));
808: DoExit(EX_ERRDEAD);
809: }
810:
811: /* Remove lock */
812:
813: if (!strncmp(pathname, "/dev/", 5))
814: {
815: ttyname = pathname + 5;
816: if (UuUnlock(ttyname) < 0)
817: Perror("[%s] can't unlock %s", label, ttyname);
818: }
819: }
820:
821: /*
822: * UuLock()
823: *
824: * Try to atomically create lockfile. Returns negative if failed.
825: */
826:
827: static int
828: UuLock(const char *ttyname)
829: {
830: int fd, pid;
831: char tbuf[sizeof(PATH_LOCKFILENAME) + MAX_FILENAME];
832: char pid_buf[64];
833:
834: snprintf(tbuf, sizeof(tbuf), PATH_LOCKFILENAME, ttyname);
835: if ((fd = open(tbuf, O_RDWR|O_CREAT|O_EXCL, 0664)) < 0)
836: {
837:
838: /* File is already locked; Check to see if the process
839: * holding the lock still exists */
840:
841: if ((fd = open(tbuf, O_RDWR, 0)) < 0)
842: {
843: Perror("%s: open(%s)", __FUNCTION__, tbuf);
844: return(-1);
845: }
846:
847: if (read(fd, pid_buf, sizeof(pid_buf)) <= 0)
848: {
849: (void)close(fd);
850: Perror("%s: read", __FUNCTION__);
851: return(-1);
852: }
853:
854: pid = atoi(pid_buf);
855:
856: if (kill(pid, 0) == 0 || errno != ESRCH)
857: {
858: (void)close(fd); /* process is still running */
859: return(-1);
860: }
861:
862: /* The process that locked the file isn't running, so we'll lock it */
863:
864: if (lseek(fd, (off_t) 0, L_SET) < 0)
865: {
866: (void)close(fd);
867: Perror("%s: lseek", __FUNCTION__);
868: return(-1);
869: }
870: }
871:
872: /* Finish the locking process */
873:
874: sprintf(pid_buf, "%10u\n", (int) gPid);
875: if (write(fd, pid_buf, strlen(pid_buf)) != strlen(pid_buf))
876: {
877: (void)close(fd);
878: (void)unlink(tbuf);
879: Perror("%s: write", __FUNCTION__);
880: return(-1);
881: }
882: (void)close(fd);
883: return(0);
884: }
885:
886: /*
887: * UuUnlock()
888: */
889:
890: static int
891: UuUnlock(const char *ttyname)
892: {
893: char tbuf[sizeof(PATH_LOCKFILENAME) + MAX_FILENAME];
894:
895: (void) sprintf(tbuf, PATH_LOCKFILENAME, ttyname);
896: return(unlink(tbuf));
897: }
898:
899: /*
900: * GenerateMagic()
901: *
902: * Generate random number which will be used as magic number.
903: * This could be made a little more "random"...
904: */
905:
906: u_long
907: GenerateMagic(void)
908: {
909: time_t now;
910: struct timeval tval;
911:
912: time(&now);
913: gettimeofday(&tval, NULL);
914: now += (tval.tv_sec ^ tval.tv_usec) + getppid();
915: now *= gPid;
916: return(now);
917: }
918:
919: /*
920: * PIDCheck()
921: *
922: * See if process is already running and deal with PID file.
923: */
924:
925: int
926: PIDCheck(const char *filename, int killem)
927: {
928: int fd = -1, n_tries;
929:
930: /* Sanity */
931:
932: assert(!lockFp);
933:
934: /* Atomically open and lock file */
935:
936: for (n_tries = 0;
937: n_tries < MAX_LOCK_ATTEMPTS
938: && (fd = open(filename, O_RDWR|O_CREAT|O_EXLOCK|O_NONBLOCK, 0644)) < 0;
939: n_tries++)
940: {
941: int nscan, old_pid;
942: FILE *fp;
943:
944: /* Abort on any unexpected errors */
945:
946: if (errno != EAGAIN)
947: {
948: Perror("%s: open(%s)", __FUNCTION__, filename);
949: return(-1);
950: }
951:
952: /* We're already running ... see who it is */
953:
954: if ((fp = fopen(filename, "r")) == NULL)
955: {
956: Perror("%s: fopen(%s)", __FUNCTION__, filename);
957: return(-1);
958: }
959:
960: /* If there's a PID in there, sniff it out */
961:
962: nscan = fscanf(fp, "%d", &old_pid);
963: fclose(fp);
964: if (nscan != 1)
965: {
966: Log(LG_ERR, ("%s: contents mangled", filename));
967: return(-1);
968: }
969:
970: /* Maybe kill the other guy */
971:
972: if (!killem)
973: {
974: Log(LG_ERR, ("already running as process %d", old_pid));
975: return(-1);
976: }
977: if (kill(old_pid, SIGTERM) < 0)
978: switch (errno)
979: {
980: case ESRCH:
981: Log(LG_ERR, ("process %d no longer exists", old_pid));
982: break;
983: default:
984: Perror("%s: kill(%d)", __FUNCTION__, old_pid);
985: return(-1);
986: }
987:
988: /* Wait and try again */
989:
990: Log(LG_ERR, ("waiting for process %d to die...", old_pid));
991: sleep(1);
992: }
993: if (n_tries == MAX_LOCK_ATTEMPTS)
994: {
995: Log(LG_ERR, ("can't lock %s after %d attempts", filename, n_tries));
996: return(-1);
997: }
998:
999: /* Close on exec */
1000:
1001: (void) fcntl(fd, F_SETFD, 1);
1002:
1003: /* Create a stream on top of file descriptor */
1004:
1005: if ((lockFp = fdopen(fd, "r+")) == NULL)
1006: {
1007: Perror("%s: fdopen", __FUNCTION__);
1008: return(-1);
1009: }
1010: setbuf(lockFp, NULL);
1011:
1012: /* Write my PID in there */
1013:
1014: rewind(lockFp);
1015: fprintf(lockFp, "%u\n", (u_int) gPid);
1016: fflush(lockFp);
1017: (void) ftruncate(fileno(lockFp), ftell(lockFp));
1018: return(0);
1019: }
1020:
1021: /*
1022: * GetInetSocket()
1023: *
1024: * Get a TCP socket and bind it to an address. Set SO_REUSEADDR on the socket.
1025: */
1026:
1027: int
1028: GetInetSocket(int type, struct u_addr *addr, in_port_t port, int block, char *ebuf, size_t len)
1029: {
1030: int sock;
1031: static int one = 1;
1032: struct sockaddr_storage sa;
1033:
1034: u_addrtosockaddr(addr,port,&sa);
1035:
1036: /* Get and bind non-blocking socket */
1037:
1038: if ((sock = socket(sa.ss_family, type, type == SOCK_STREAM ? IPPROTO_TCP : 0)) < 0)
1039: {
1040: snprintf(ebuf, len, "socket: %s", strerror(errno));
1041: return(-1);
1042: }
1043: (void) fcntl(sock, F_SETFD, 1);
1044: if (!block)
1045: {
1046: if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0)
1047: {
1048: snprintf(ebuf, len, "can't set socket non-blocking: %s", strerror(errno));
1049: close(sock);
1050: return(-1);
1051: }
1052: }
1053: if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)))
1054: {
1055: snprintf(ebuf, len, "setsockopt: %s", strerror(errno));
1056: close(sock);
1057: return(-1);
1058: }
1059:
1060: if (bind(sock, (struct sockaddr *) &sa, sa.ss_len) < 0)
1061: {
1062: snprintf(ebuf, len, "bind: %s", strerror(errno));
1063: close(sock);
1064: return(-1);
1065: }
1066:
1067: return(sock);
1068: }
1069:
1070:
1071: /*
1072: * TcpGetListenPort()
1073: *
1074: * Get port for incoming telnet connections
1075: */
1076:
1077: int
1078: TcpGetListenPort(struct u_addr *addr, in_port_t port, int block)
1079: {
1080: char ebuf[100];
1081: int sock;
1082: int saverrno;
1083:
1084: /* Get socket */
1085:
1086: if ((sock = GetInetSocket(SOCK_STREAM, addr, port, block, ebuf, sizeof(ebuf))) < 0)
1087: {
1088: saverrno = errno;
1089: Log(LG_ERR, ("%s", ebuf));
1090: errno = saverrno;
1091: return(-1);
1092: }
1093:
1094: /* Make socket available for connections */
1095:
1096: if (listen(sock, 2) < 0)
1097: {
1098: Perror("%s: listen", __FUNCTION__);
1099: (void) close(sock);
1100: return(-1);
1101: }
1102:
1103: /* Done */
1104:
1105: return(sock);
1106: }
1107:
1108:
1109: /*
1110: * TcpAcceptConnection()
1111: *
1112: * Accept next connection on port
1113: */
1114:
1115: int
1116: TcpAcceptConnection(int sock, struct sockaddr_storage *addr, int block)
1117: {
1118: int new_sock;
1119: socklen_t size=sizeof(struct sockaddr_storage);
1120:
1121: /* Accept incoming connection */
1122:
1123: memset(addr, 0, sizeof(*addr));
1124: if ((new_sock = accept(sock, (struct sockaddr *) addr, &size)) < 0) {
1125: Perror("%s: accept", __FUNCTION__);
1126: return(-1);
1127: }
1128:
1129: #ifdef USE_WRAP
1130: if (Enabled(&gGlobalConf.options, GLOBAL_CONF_TCPWRAPPER)) {
1131: struct request_info req;
1132: request_init(&req, RQ_DAEMON, "mpd", RQ_FILE, new_sock, NULL);
1133: fromhost(&req);
1134: if (!hosts_access(&req)) {
1135: Log(LG_ERR, ("refused connection (tcp-wrapper) from %s",
1136: eval_client(&req)));
1137: close(new_sock);
1138: return(-1);
1139: }
1140: }
1141: #endif
1142:
1143: if (!block)
1144: {
1145: (void) fcntl(new_sock, F_SETFD, 1);
1146: if (fcntl(new_sock, F_SETFL, O_NONBLOCK) < 0) {
1147: Perror("%s: fcntl", __FUNCTION__);
1148: return(-1);
1149: }
1150: }
1151:
1152: /* Done */
1153:
1154: return(new_sock);
1155: }
1156:
1157:
1158: /*
1159: * ShowMesg()
1160: */
1161:
1162: void
1163: ShowMesg(int log, const char *pref, const char *buf, int len)
1164: {
1165: char *s, mesg[256];
1166:
1167: if (len > 0)
1168: {
1169: if (len > sizeof(mesg) - 1)
1170: len = sizeof(mesg) - 1;
1171: memcpy(mesg, buf, len);
1172: mesg[len] = 0;
1173: for (s = strtok(mesg, "\r\n"); s; s = strtok(NULL, "\r\n"))
1174: Log(log, ("[%s] MESG: %s", pref, s));
1175: }
1176: }
1177:
1178: /*
1179: * Bin2Hex()
1180: */
1181:
1182: char *
1183: Bin2Hex(const unsigned char *bin, size_t len)
1184: {
1185: static char hexconvtab[] = "0123456789abcdef";
1186: size_t i, j;
1187: char *buf;
1188:
1189: buf = Malloc(MB_UTIL, len * 2 + 1);
1190: for (i = j = 0; i < len; i++) {
1191: buf[j++] = hexconvtab[bin[i] >> 4];
1192: buf[j++] = hexconvtab[bin[i] & 15];
1193: }
1194: buf[j] = 0;
1195: return buf;
1196: }
1197:
1198: /*
1199: * Hex2Bin()
1200: */
1201:
1202: u_char *
1203: Hex2Bin(char *hexstr)
1204: {
1205: int i;
1206: u_char *binval;
1207:
1208: binval = Malloc(MB_UTIL, strlen(hexstr) / 2);
1209:
1210: for (i = 0; i < strlen(hexstr) / 2; i++) {
1211: binval[i] = 16 * HexVal(hexstr[2*i]) + HexVal(hexstr[2*i+1]);
1212: }
1213:
1214: return binval;
1215: }
1216:
1217: static char
1218: HexVal(char c)
1219: {
1220: if (c >= '0' && c <= '9') {
1221: return (c - '0');
1222: } else if (c >= 'a' && c <= 'z') {
1223: return (c - 'a' + 10);
1224: } else if (c >= 'A' && c <= 'Z') {
1225: return (c - 'A' + 10);
1226: } else {
1227: return (-1);
1228: }
1229: }
1230:
1231: /*
1232: * Crc16()
1233: *
1234: * Compute the 16 bit frame check value, per RFC 1171 Appendix B,
1235: * on an array of bytes.
1236: */
1237:
1238: u_short
1239: Crc16(u_short crc, u_char *cp, int len)
1240: {
1241: while (len--)
1242: crc = (crc >> 8) ^ Crc16Table[(crc ^ *cp++) & 0xff];
1243: return(crc);
1244: }
1245:
1246: /*
1247: * GetAnyIpAddress()
1248: *
1249: * Get any non-loopback IP address owned by this machine
1250: * Prefer addresses from non-point-to-point interfaces.
1251: */
1252:
1253: int
1254: GetAnyIpAddress(struct u_addr *ipaddr, const char *ifname)
1255: {
1256: int s, p2p = 0;
1257: struct in_addr ipa = { 0 };
1258: static struct in_addr nipa = { 0 };
1259: static int have_nipa = 0;
1260: struct ifreq *ifr, *ifend;
1261: struct ifreq ifreq;
1262: struct ifconf ifc;
1263: unsigned int buffsize = IFCONF_BUFFSIZE;
1264:
1265: /* use cached IP to reduce number of syscalls */
1266: if (ifname == NULL && have_nipa) {
1267: in_addrtou_addr(&nipa, ipaddr);
1268: return(0);
1269: }
1270:
1271: /* Get socket */
1272: if ((s = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
1273: Perror("%s: Socket creation error", __FUNCTION__);
1274: return(-1);
1275: }
1276:
1277: /* Try simple call for the first IP on interface */
1278: if (ifname != NULL) {
1279: strlcpy(ifreq.ifr_name, ifname, sizeof(ifreq.ifr_name));
1280: if (ioctl(s, SIOCGIFADDR, &ifreq) < 0) {
1281: if (errno != ENXIO)
1282: Perror("%s: ioctl(SIOCGIFADDR)", __FUNCTION__);
1283: close(s);
1284: return(-1);
1285: }
1286: ipa = ((struct sockaddr_in *)&ifreq.ifr_ifru.ifru_addr)->sin_addr;
1287: if ((ntohl(ipa.s_addr)>>24) == 127)
1288: ipa.s_addr = 0; /* We don't like 127.0.0.1 */
1289: }
1290:
1291: /* If simple is not enouth try complex call */
1292: if (ipa.s_addr == 0) {
1293: struct ifreq *ifs;
1294: while (1) {
1295: ifc.ifc_len = buffsize;
1296: ifc.ifc_req = ifs = Malloc(MB_UTIL, ifc.ifc_len);
1297: if (ioctl(s, SIOCGIFCONF, &ifc) < 0) {
1298: Freee(ifs);
1299: if (errno != ENXIO)
1300: Perror("%s: ioctl(SIOCGIFCONF)", __FUNCTION__);
1301: close(s);
1302: return(-1);
1303: }
1304:
1305: /* if used size is too close to allocated size retry with a larger buffer */
1306: if (ifc.ifc_len + 128 < buffsize)
1307: break;
1308:
1309: Freee(ifs);
1310: if (buffsize >= IFCONF_BUFFMAXSIZE) {
1311: Log(LG_ERR, ("%s: Max buffer size reached", __FUNCTION__));
1312: close(s);
1313: return(-1);
1314: }
1315: buffsize *= 2;
1316: }
1317:
1318: for (ifend = (struct ifreq *)(void *)(ifc.ifc_buf + ifc.ifc_len),
1319: ifr = ifc.ifc_req;
1320: ifr < ifend;
1321: ifr = (struct ifreq *)(void *)((char *) &ifr->ifr_addr
1322: + MAX(ifr->ifr_addr.sa_len, sizeof(ifr->ifr_addr)))) {
1323: if (ifr->ifr_addr.sa_family == AF_INET) {
1324:
1325: if (ifname!=NULL && strcmp(ifname,ifr->ifr_name))
1326: continue;
1327:
1328: /* Check that the interface is up; prefer non-p2p and non-loopback */
1329: strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1330: if (ioctl(s, SIOCGIFFLAGS, &ifreq) < 0)
1331: continue;
1332: if ((ifreq.ifr_flags & IFF_UP) != IFF_UP)
1333: continue;
1334: if ((ifreq.ifr_flags & (IFF_POINTOPOINT|IFF_LOOPBACK)) && ipa.s_addr)
1335: continue;
1336: if ((ntohl(((struct sockaddr_in *)(void *)&ifr->ifr_addr)->sin_addr.s_addr)>>24)==127)
1337: continue;
1338:
1339: /* Save IP address and interface name */
1340: ipa = ((struct sockaddr_in *)(void *)&ifr->ifr_addr)->sin_addr;
1341: p2p = (ifreq.ifr_flags & (IFF_POINTOPOINT|IFF_LOOPBACK)) != 0;
1342:
1343: if (!p2p) break;
1344: }
1345: }
1346: Freee(ifs);
1347: }
1348: close(s);
1349:
1350: /* Found? */
1351: if (ipa.s_addr == 0)
1352: return(-1);
1353: if (ifname == NULL) {
1354: nipa = ipa;
1355: have_nipa = 1;
1356: }
1357: in_addrtou_addr(&ipa, ipaddr);
1358: return(0);
1359: }
1360:
1361: /*
1362: * GetEther()
1363: *
1364: * Get the hardware address of an interface on the the same subnet as addr.
1365: * If addr == NULL, finds the address of any local ethernet interface.
1366: */
1367:
1368: int
1369: GetEther(struct u_addr *addr, struct sockaddr_dl *hwaddr)
1370: {
1371: int s;
1372: struct ifreq *ifr, *bifr, *ifend, *ifp;
1373: u_int32_t ina, mask, bmask;
1374: struct ifreq ifreq;
1375: struct ifconf ifc;
1376: struct ifreq *ifs;
1377: unsigned int buffsize = IFCONF_BUFFSIZE;
1378:
1379: static struct sockaddr_dl nhwaddr;
1380: static int have_nhwaddr = 0;
1381:
1382: /* cache value to reduce number of syscalls */
1383: if (addr == NULL && have_nhwaddr) {
1384: memcpy(hwaddr, &nhwaddr,
1385: sizeof(*hwaddr));
1386: return(0);
1387: }
1388:
1389: /* Get interface list */
1390: if ((s = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
1391: Perror("%s: Socket creation error", __FUNCTION__);
1392: return(-1);
1393: }
1394:
1395: while (1) {
1396: ifc.ifc_len = buffsize;
1397: ifc.ifc_req = ifs = Malloc(MB_UTIL, ifc.ifc_len);
1398: if (ioctl(s, SIOCGIFCONF, &ifc) < 0) {
1399: Freee(ifs);
1400: Perror("%s: ioctl(SIOCGIFCONF)", __FUNCTION__);
1401: close(s);
1402: return(-1);
1403: }
1404:
1405: /* if used size is too close to allocated size retry with a larger buffer */
1406: if (ifc.ifc_len + 128 < buffsize)
1407: break;
1408:
1409: Freee(ifs);
1410: if (buffsize >= IFCONF_BUFFMAXSIZE) {
1411: Log(LG_ERR, ("%s: Max buffer size reached", __FUNCTION__));
1412: close(s);
1413: return(-1);
1414: }
1415: buffsize *= 2;
1416: }
1417:
1418: /*
1419: * Scan through looking for an interface with an IP
1420: * address on same subnet as `addr'.
1421: */
1422: bifr = NULL;
1423: bmask = 0;
1424: for (ifend = (struct ifreq *)(void *)(ifc.ifc_buf + ifc.ifc_len),
1425: ifr = ifc.ifc_req;
1426: ifr < ifend;
1427: ifr = (struct ifreq *)(void *)((char *) &ifr->ifr_addr
1428: + MAX(ifr->ifr_addr.sa_len, sizeof(ifr->ifr_addr)))) {
1429: if (ifr->ifr_addr.sa_family == AF_INET) {
1430:
1431: /* Save IP address and interface name */
1432: ina = ((struct sockaddr_in *)(void *)&ifr->ifr_addr)->sin_addr.s_addr;
1433: strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1434: ifreq.ifr_addr = ifr->ifr_addr;
1435:
1436: /* Check that the interface is up, and not point-to-point or loopback */
1437: if (ioctl(s, SIOCGIFFLAGS, &ifreq) < 0)
1438: continue;
1439: if ((ifreq.ifr_flags &
1440: (IFF_UP|IFF_BROADCAST|IFF_POINTOPOINT|IFF_LOOPBACK|IFF_NOARP))
1441: != (IFF_UP|IFF_BROADCAST))
1442: continue;
1443:
1444: if (addr) {
1445: /* Get its netmask and check that it's on the right subnet */
1446: if (ioctl(s, SIOCGIFNETMASK, &ifreq) < 0)
1447: continue;
1448: mask = ((struct sockaddr_in *)(void *)&ifreq.ifr_addr)->sin_addr.s_addr;
1449: if ((addr->u.ip4.s_addr & mask) != (ina & mask))
1450: continue;
1451: /* Is this the best match? */
1452: if (mask >= bmask) {
1453: bmask = mask;
1454: bifr = ifr;
1455: }
1456: continue;
1457: }
1458:
1459: /* OK */
1460: bifr = ifr;
1461: break;
1462: }
1463: }
1464: close(s);
1465:
1466: /* Found? */
1467: if (bifr == NULL) {
1468: Freee(ifs);
1469: return(-1);
1470: }
1471:
1472: /* Now scan again looking for a link-level address for this interface */
1473: for (ifp = bifr, ifr = ifc.ifc_req; ifr < ifend; ) {
1474: if (strcmp(ifp->ifr_name, ifr->ifr_name) == 0
1475: && ifr->ifr_addr.sa_family == AF_LINK) {
1476: if (addr == NULL) {
1477: memcpy(&nhwaddr, (struct sockaddr_dl *)(void *)&ifr->ifr_addr,
1478: sizeof(*hwaddr));
1479: have_nhwaddr = 1;
1480: }
1481: memcpy(hwaddr, (struct sockaddr_dl *)(void *)&ifr->ifr_addr,
1482: sizeof(*hwaddr));
1483: Freee(ifs);
1484: return(0);
1485: }
1486: ifr = (struct ifreq *)(void *)((char *)&ifr->ifr_addr
1487: + MAX(ifr->ifr_addr.sa_len, sizeof(ifr->ifr_addr)));
1488: }
1489:
1490: /* Not found! */
1491: Freee(ifs);
1492: return(-1);
1493: }
1494:
1495: int
1496: GetPeerEther(struct u_addr *addr, struct sockaddr_dl *hwaddr)
1497: {
1498: int mib[6];
1499: size_t needed;
1500: char *lim, *buf, *next;
1501: struct rt_msghdr *rtm;
1502: struct sockaddr_inarp *sin2;
1503: struct sockaddr_dl *sdl;
1504: int st, found_entry = 0;
1505:
1506: mib[0] = CTL_NET;
1507: mib[1] = PF_ROUTE;
1508: mib[2] = 0;
1509: mib[3] = addr->family;
1510: mib[4] = NET_RT_FLAGS;
1511: #ifdef RTF_LLINFO
1512: mib[5] = RTF_LLINFO;
1513: #else
1514: mib[5] = 0;
1515: #endif
1516: if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) {
1517: Log(LG_ERR, ("route-sysctl-estimate"));
1518: return (0);
1519: }
1520: if (needed == 0) /* empty table */
1521: return 0;
1522: buf = NULL;
1523: for (;;) {
1524: if (buf)
1525: Freee(buf);
1526: buf = Malloc(MB_UTIL, needed);
1527: st = sysctl(mib, 6, buf, &needed, NULL, 0);
1528: if (st == 0 || errno != ENOMEM)
1529: break;
1530: needed += needed / 8;
1531: }
1532: if (st == -1) {
1533: Log(LG_ERR, ("actual retrieval of routing table"));
1534: Freee(buf);
1535: return (0);
1536: }
1537: lim = buf + needed;
1538: for (next = buf; next < lim; next += rtm->rtm_msglen) {
1539: rtm = (struct rt_msghdr *)next;
1540: sin2 = (struct sockaddr_inarp *)(rtm + 1);
1541: if (addr->u.ip4.s_addr == sin2->sin_addr.s_addr) {
1542: sdl = (struct sockaddr_dl *)((char *)sin2 + SA_SIZE(sin2));
1543: memcpy(hwaddr, sdl, sdl->sdl_len);
1544: found_entry = 1;
1545: break;
1546: }
1547: }
1548: Freee(buf);
1549: return (found_entry);
1550: }
1551:
1552: /*
1553: * Decode ASCII message
1554: */
1555: void
1556: ppp_util_ascify(char *buf, size_t bsiz, const char *data, size_t len)
1557: {
1558: char *bp;
1559: int i;
1560:
1561: for (bp = buf, i = 0; i < len; i++) {
1562: const char ch = (char)data[i];
1563:
1564: if (bsiz < 3)
1565: break;
1566: switch (ch) {
1567: case '\t':
1568: *bp++ = '\\';
1569: *bp++ = 't';
1570: bsiz -= 2;
1571: break;
1572: case '\n':
1573: *bp++ = '\\';
1574: *bp++ = 'n';
1575: bsiz -= 2;
1576: break;
1577: case '\r':
1578: *bp++ = '\\';
1579: *bp++ = 'r';
1580: bsiz -= 2;
1581: break;
1582: default:
1583: if (isprint(ch & 0x7f)) {
1584: *bp++ = ch;
1585: bsiz--;
1586: } else {
1587: *bp++ = '^';
1588: *bp++ = '@' + (ch & 0x1f);
1589: bsiz -= 2;
1590: }
1591: break;
1592: }
1593: }
1594: *bp = '\0';
1595: }
1596:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to util.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mpd / src