![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to conn.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / usr.bin / uucp|
Return to conn.c CVS log | Up to [CSRG BSD Unix] / 42BSD / usr.bin / uucp |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)conn.c 5.3 (Berkeley) 8/13/83";
3: #endif
4:
5: #include "uucp.h"
6: #include <signal.h>
7: #include <setjmp.h>
8: #include <ctype.h>
9: #include <sys/types.h>
10: #include <sys/time.h>
11: #include <errno.h>
12: #ifdef SYSIII
13: #include <termio.h>
14: #include <fcntl.h>
15: #endif
16: #ifndef SYSIII
17: #include <sgtty.h>
18: #endif
19:
20: #define MAXC 1000
21:
22: extern jmp_buf Sjbuf;
23: extern int errno;
24:
25: /* Parity control during login procedure */
26: #define P_ZERO 0
27: #define P_ONE 1
28: #define P_EVEN 2
29: #define P_ODD 3
30: char par_tab[128]; /* must be power of two */
31:
32: int next_fd = -1; /* predicted fd to close interrupted opens */
33: /* rti!trt, courtesy unc!smb */
34: /***
35: * alarmtr() - catch alarm routine for "expect".
36: */
37: alarmtr()
38: {
39: signal(SIGALRM, alarmtr);
40: if (next_fd >= 0) {
41: if (close(next_fd))
42: logent("FAIL", "ACU LINE CLOSE");
43: next_fd = -1;
44: }
45: longjmp(Sjbuf, 1);
46: }
47:
48: /*******
49: * conn(system)
50: * char *system;
51: *
52: * conn - place a telephone call to system and
53: * login, etc.
54: *
55: * return codes:
56: * CF_SYSTEM: don't know system
57: * CF_TIME: wrong time to call
58: * CF_DIAL: call failed
59: * CF_NODEV: no devices available to place call
60: * CF_LOGIN: login/password dialog failed
61: *
62: * >0 - file no. - connect ok
63: *
64: */
65:
66: int Dcf = -1;
67:
68: conn(system)
69: char *system;
70: {
71: int ret, nf;
72: register int fn, fnd;
73: char info[MAXC], *flds[MAXC/10];
74: register FILE *fsys;
75: int fcode = 0;
76:
77: nf = 0;
78: fnd = 0;
79:
80:
81: fsys = fopen(SYSFILE, "r");
82: ASSERT(fsys != NULL, "CAN'T OPEN", SYSFILE, 0);
83:
84: DEBUG(4, "finds %s\n", "called");
85: while((nf = finds(fsys, system, info, flds)) > 0) {
86: DEBUG(4, "getto %s\n", "called");
87: if ((fn = getto(flds)) > 0) {
88: fnd = 1;
89: Dcf = fn;
90: break;
91: }
92: fcode = (fn == FAIL ? CF_DIAL : fn);
93: }
94: fclose(fsys);
95:
96: if (nf <= 0)
97: return(fcode ? fcode : nf);
98:
99: DEBUG(4, "login %s\n", "called");
100: ret = login(nf, flds, fn);
101: if (ret < 0) {
102: clsacu();
103: return(CF_LOGIN);
104: }
105: /* rti!trt: avoid passing file to children */
106: fioclex(fn);
107: return(fn);
108: }
109:
110: /***
111: * getto(flds) connect to remote machine
112: * char *flds[];
113: *
114: * return codes:
115: * >0 - file number - ok
116: * FAIL - failed
117: */
118:
119: getto(flds)
120: register char *flds[];
121: {
122: register struct condev *cd;
123: int nulldev(), diropn();
124:
125: DEBUG(4, "call: no. %s ", flds[F_PHONE]);
126: DEBUG(4, "for sys %s\n", flds[F_NAME]);
127:
128: CU_end = nulldev;
129: for (cd = condevs; cd->CU_meth != NULL; cd++) {
130: if (snccmp(cd->CU_meth, flds[F_LINE]) == SAME) {
131: DEBUG(4, "Using %s to call\n", cd->CU_meth);
132: return((*(cd->CU_gen))(flds));
133: }
134: }
135: logent(flds[F_LINE], "getto: Can't find, using DIR");
136: return(diropn(flds)); /* search failed, so use direct */
137: }
138:
139: /***
140: * clsacu() close call unit
141: *
142: * return codes: none
143: */
144:
145: int (*CU_end)() = nulldev;
146: clsacu()
147: {
148: (*(CU_end))(Dcf);
149: if (close(Dcf) == 0) {
150: DEBUG(4, "fd %d NOT CLOSED by CU_clos\n", Dcf);
151: logent("clsacu", "NOT CLOSED by CU_clos");
152: }
153: Dcf = -1;
154: CU_end = nulldev;
155: }
156:
157: /***
158: * exphone - expand phone number for given prefix and number
159: *
160: * return code - none
161: */
162:
163: exphone(in, out)
164: register char *in, *out;
165: {
166: FILE *fn;
167: char pre[MAXPH], npart[MAXPH], tpre[MAXPH], p[MAXPH];
168: char buf[BUFSIZ];
169: register char *s1;
170:
171: if (!isalpha(*in)) {
172: strcpy(out, in);
173: return;
174: }
175:
176: s1=pre;
177: while (isalpha(*in))
178: *s1++ = *in++;
179: *s1 = '\0';
180: s1 = npart;
181: while (*in != '\0')
182: *s1++ = *in++;
183: *s1 = '\0';
184:
185: tpre[0] = '\0';
186: if ((fn = fopen(DIALFILE, "r")) == NULL)
187: DEBUG(2, "CAN'T OPEN %s\n", DIALFILE);
188: else {
189: while (cfgets(buf, BUFSIZ, fn)) {
190: sscanf(buf, "%s%s", p, tpre);
191: if (strcmp(p, pre) == SAME)
192: goto found;
193: tpre[0] = '\0';
194: }
195: DEBUG(2, "CAN'T FIND dialcodes prefix '%s'\n", pre);
196: found:;
197: fclose(fn);
198: }
199:
200: strcpy(out, tpre);
201: strcat(out, npart);
202: return;
203: }
204:
205: /***
206: * rddev - read and decode a line from device file
207: *
208: * return code - FAIL at end-of file; 0 otherwise
209: */
210:
211: rddev(fp, dev)
212: register struct Devices *dev;
213: FILE *fp;
214: {
215: char *fdig();
216: char buf[BUFSIZ];
217: int na;
218:
219: if (!cfgets(buf, BUFSIZ, fp))
220: return(FAIL);
221:
222: na = sscanf(buf, "%s%s%s%s%s", dev->D_type, dev->D_line,
223: dev->D_calldev, dev->D_class, dev->D_brand);
224: ASSERT(na >= 4, "BAD DEVICE ENTRY", buf, 0);
225: if (na != 5) dev->D_brand[0] = '\0';
226: dev->D_speed = atoi(fdig(dev->D_class));
227: return(0);
228: }
229:
230: /***
231: * finds(fsys, sysnam, info, flds) set system attribute vector
232: *
233: * return codes:
234: * >0 - number of arguments in vector - succeeded
235: * CF_SYSTEM - system name not found
236: * CF_TIME - wrong time to call
237: */
238:
239: finds(fsys, sysnam, info, flds)
240: char *sysnam, info[], *flds[];
241: FILE *fsys;
242: {
243: char sysn[8];
244: int na;
245: int fcode = 0;
246:
247: /* format of fields
248: * 0 name;
249: * 1 time
250: * 2 acu/hardwired
251: * 3 speed
252: * etc
253: */
254: while (cfgets(info, MAXC, fsys) != NULL) {
255: na = getargs(info, flds);
256: sprintf(sysn, "%.7s", flds[F_NAME]);
257: if (strcmp(sysnam, sysn) != SAME)
258: continue;
259: if (ifdate(flds[F_TIME]))
260: /* found a good entry */
261: return(na);
262: DEBUG(2, "Wrong time ('%s') to call\n", flds[F_TIME]);
263: fcode = CF_TIME;
264: }
265: return(fcode ? fcode : CF_SYSTEM);
266: }
267:
268: /***
269: * login(nf, flds, dcr) do login conversation
270: * char *flds[];
271: * int nf;
272: *
273: * return codes: 0 | FAIL
274: */
275:
276: login(nf, flds, fn)
277: register char *flds[];
278: int nf, fn;
279: {
280: register char *want, *altern;
281: extern char *index();
282: int k, ok;
283:
284: ASSERT(nf > 4, "TOO FEW LOG FIELDS", "", nf);
285: for (k = F_LOGIN; k < nf; k += 2) {
286: want = flds[k];
287: ok = FAIL;
288: while (ok != 0) {
289: altern = index(want, '-');
290: if (altern != NULL)
291: *altern++ = '\0';
292: DEBUG(4, "wanted %s ", want);
293: ok = expect(want, fn);
294: DEBUG(4, "got %s\n", ok ? "?" : "that");
295: if (ok == 0)
296: break;
297: if (altern == NULL) {
298: logent("LOGIN", "FAILED");
299: /* close *not* needed here. rti!trt */
300: return(FAIL);
301: }
302: want = index(altern, '-');
303: if (want != NULL)
304: *want++ = '\0';
305: sendthem(altern, fn);
306: }
307: sleep(2);
308: if (k+1 < nf)
309: sendthem(flds[k+1], fn);
310: }
311: return(0);
312: }
313:
314:
315: /* rti!trt: conditional table generation to support odd speeds */
316: /* Suggested in n44a.139 by n44!dan (Dan Ts'o) */
317: struct sg_spds {int sp_val, sp_name;} spds[] = {
318: #ifdef B50
319: { 50, B50},
320: #endif
321: #ifdef B75
322: { 75, B75},
323: #endif
324: #ifdef B110
325: { 110, B110},
326: #endif
327: #ifdef B150
328: { 150, B150},
329: #endif
330: #ifdef B200
331: { 200, B200},
332: #endif
333: #ifdef B300
334: { 300, B300},
335: #endif
336: #ifdef B600
337: {600, B600},
338: #endif
339: #ifdef B1200
340: {1200, B1200},
341: #endif
342: #ifdef B1800
343: {1800, B1800},
344: #endif
345: #ifdef B2000
346: {2000, B2000},
347: #endif
348: #ifdef B2400
349: {2400, B2400},
350: #endif
351: #ifdef B3600
352: {3600, B3600},
353: #endif
354: #ifdef B4800
355: {4800, B4800},
356: #endif
357: #ifdef B7200
358: {7200, B7200},
359: #endif
360: #ifdef B9600
361: {9600, B9600},
362: #endif
363: #ifdef B19200
364: {19200,B19200},
365: #endif
366: {0, 0}
367: };
368:
369: /***
370: * fixline(tty, spwant) set speed/echo/mode...
371: * int tty, spwant;
372: *
373: * return codes: none
374: */
375:
376: fixline(tty, spwant)
377: int tty, spwant;
378: {
379: #ifdef SYSIII
380: struct termio ttbuf;
381: #endif
382: #ifndef SYSIII
383: struct sgttyb ttbuf;
384: #endif
385: register struct sg_spds *ps;
386: int speed = -1;
387: int ret;
388:
389: for (ps = spds; ps->sp_val; ps++)
390: if (ps->sp_val == spwant)
391: speed = ps->sp_name;
392: ASSERT(speed >= 0, "BAD SPEED", "", speed);
393: #ifdef SYSIII
394: ioctl(tty, TCGETA, &ttbuf);
395: /* ttbuf.sg_flags = (ANYP|RAW);
396: ttbuf.sg_ispeed = ttbuf.sg_ospeed = speed; */
397: ttbuf.c_iflag = (ushort)0;
398: ttbuf.c_oflag = (ushort)0;
399: ttbuf.c_cflag = (speed|CS8|HUPCL|CREAD);
400: ttbuf.c_lflag = (ushort)0;
401: ttbuf.c_cc[VMIN] = 6;
402: ttbuf.c_cc[VTIME] = 1;
403: ret = ioctl(tty, TCSETA, &ttbuf);
404: #endif
405: #ifndef SYSIII
406: ioctl(tty, TIOCGETP, &ttbuf);
407: ttbuf.sg_flags = (ANYP|RAW);
408: ttbuf.sg_ispeed = ttbuf.sg_ospeed = speed;
409: ret = ioctl(tty, TIOCSETP, &ttbuf);
410: #endif
411: ASSERT(ret >= 0, "RETURN FROM STTY", "", ret);
412: #ifndef SYSIII
413: ioctl(tty, TIOCHPCL, STBNULL);
414: ioctl(tty, TIOCEXCL, STBNULL);
415: #endif
416: return;
417: }
418:
419:
420: /* Bill Shannon recommends MR 2000, but that takes too much space on PDPs */
421: /* Actually, the 'expect' algorithm should be rewritten. */
422: #define MR 1000
423:
424:
425: /***
426: * expect(str, fn) look for expected string
427: * char *str;
428: *
429: * return codes:
430: * 0 - found
431: * FAIL - lost line or too many characters read
432: * some character - timed out
433: */
434:
435: expect(str, fn)
436: register char *str;
437: int fn;
438: {
439: char rdvec[MR];
440: register char *rp = rdvec;
441: int kr;
442: char nextch;
443:
444: if (strcmp(str, "\"\"") == SAME)
445: return(0);
446: *rp = 0;
447: if (setjmp(Sjbuf)) {
448: return(FAIL);
449: }
450: signal(SIGALRM, alarmtr);
451: /* change MAXCHARTIME to MAXMSGTIME, outside while loop -- brl-bmd!dpk */
452: alarm(MAXMSGTIME);
453: while (notin(str, rdvec)) {
454: kr = read(fn, &nextch, 1);
455: if (kr <= 0) {
456: alarm(0);
457: DEBUG(4, "lost line kr - %d\n, ", kr);
458: logent("LOGIN", "LOST LINE");
459: return(FAIL);
460: }
461: {
462: int c;
463: c = nextch & 0177;
464: DEBUG(4, c >= 040 ? "%c" : "\\%03o", c);
465: }
466: if ((*rp = nextch & 0177) != '\0')
467: rp++;
468: /* Check rdvec before null termination -- cmcl2!salkind */
469: if (rp >= rdvec + MR) {
470: alarm(0);
471: return(FAIL);
472: }
473: *rp = '\0';
474: }
475: alarm(0);
476: return(0);
477: }
478:
479:
480: /*
481: * Determine next file descriptor that would be allocated.
482: * This permits later closing of a file whose open was interrupted.
483: * It is a UNIX kernel problem, but it has to be handled.
484: * unc!smb (Steve Bellovin) probably first discovered it.
485: */
486: getnextfd()
487: {
488: close(next_fd = open("/", 0));
489: }
490:
491: /***
492: * sendthem(str, fn) send line of login sequence
493: * char *str;
494: *
495: * return codes: none
496: */
497:
498: sendthem(str, fn)
499: register char *str;
500: int fn;
501: {
502: register char *strptr;
503: int i, n, cr = 1;
504: static int p_init = 0;
505:
506: /* Note: debugging authorized only for privileged users */
507: DEBUG(5, "send %s\n", str);
508:
509: if (!p_init) {
510: p_init++;
511: bld_partab(P_EVEN);
512: }
513:
514: if (prefix("BREAK", str)) {
515: sscanf(&str[5], "%1d", &i);
516: if (i <= 0 || i > 10)
517: i = 3;
518: /* send break */
519: genbrk(fn, i);
520: return;
521: }
522:
523: if (prefix("PAUSE", str)) {
524: sscanf(&str[5], "%1d", &i);
525: if (i <= 0 || i > 10)
526: i = 3;
527: /* pause for a while */
528: sleep((unsigned)i);
529: return;
530: }
531:
532: if (strcmp(str, "EOT") == SAME) {
533: p_chwrite(fn, '\04');
534: return;
535: }
536:
537: /* LF, CR, and "" courtesy unc!smb */
538: /* Send a '\n' */
539: if (strcmp(str, "LF") == SAME)
540: str = "\\n\\c";
541:
542: /* Send a '\r' */
543: if (strcmp(str, "CR") == SAME)
544: str = "\\r\\c";
545:
546: /* Set parity as needed */
547: if (strcmp(str, "P_ZERO") == SAME) {
548: bld_partab(P_ZERO);
549: return;
550: }
551: if (strcmp(str, "P_ONE") == SAME) {
552: bld_partab(P_ONE);
553: return;
554: }
555: if (strcmp(str, "P_EVEN") == SAME) {
556: bld_partab(P_EVEN);
557: return;
558: }
559: if (strcmp(str, "P_ODD") == SAME) {
560: bld_partab(P_ODD);
561: return;
562: }
563:
564: /* If "", just send '\r' */
565: if (strcmp(str, "\"\"") != SAME)
566: for (strptr = str; *strptr; strptr++) {
567: if (*strptr == '\\') switch(*++strptr) {
568: case 's':
569: DEBUG(5, "BLANK\n", "");
570: *strptr = ' ';
571: break;
572: case 'd':
573: DEBUG(5, "DELAY\n", "");
574: sleep(1);
575: continue;
576: case 'r':
577: DEBUG(5, "RETURN\n", "");
578: *strptr = '\r';
579: break;
580: case 'b':
581: if (isdigit(*(strptr+1))) {
582: i = (*++strptr - '0');
583: if (i <= 0 || i > 10)
584: i = 3;
585: } else
586: i = 3;
587: /* send break */
588: genbrk(fn, i);
589: continue;
590: case 'c':
591: if (*(strptr+1) == '\0') {
592: DEBUG(5, "NO CR\n", "");
593: cr = 0;
594: continue;
595: }
596: DEBUG(5, "NO CR - MIDDLE IGNORED\n", "");
597: continue;
598: default:
599: if (isdigit(strptr[1])) {
600: i = 0;
601: n = 0;
602: while (isdigit(strptr[1]) && ++n <= 3)
603: i = i*8 + (*++strptr - '0');
604: p_chwrite(fn, i);
605: continue;
606: }
607: DEBUG(5, "BACKSLASH\n", "");
608: strptr--;
609: }
610: p_chwrite(fn, *strptr);
611: }
612:
613: /* '\n' changed to '\r'--a better default. rti!trt */
614: if (cr)
615: p_chwrite(fn, '\r');
616: return;
617: }
618:
619: p_chwrite(fd, c)
620: int fd;
621: int c;
622: {
623: char t[2];
624:
625: t[0] = par_tab[c&0177];
626: t[1] = '\0';
627: ASSERT(write(fd, t, 1) == 1, "BAD WRITE", "", t[0]);
628: }
629:
630: /*
631: * generate parity table for use by p_chwrite.
632: */
633: bld_partab(type)
634: int type;
635: {
636: register int i, j, n;
637:
638: for (i = 0; i < sizeof(par_tab); i++) {
639: n = 0;
640: for (j = i&(sizeof(par_tab)-1); j; j = (j-1)&j)
641: n++;
642: par_tab[i] = i;
643: if (type == P_ONE
644: || (type == P_EVEN && (n&01) != 0)
645: || (type == P_ODD && (n&01) == 0))
646: par_tab[i] |= sizeof(par_tab);
647: }
648: }
649:
650: #define BSPEED B150
651:
652: /***
653: * genbrk send a break
654: *
655: * return codes; none
656: */
657:
658: genbrk(fn, bnulls)
659: register int fn, bnulls;
660: {
661: register int ret;
662: #ifdef SYSIII
663: ret = ioctl(fn, TCSBRK, STBNULL);
664: DEBUG(5, "break ioctl ret %d\n", ret);
665: #endif
666: #ifndef SYSIII
667: #ifdef TIOCSBRK
668: ret = ioctl(fn, TIOCSBRK, STBNULL);
669: DEBUG(5, "break ioctl ret %d\n", ret);
670: #ifdef TIOCCBRK
671: ret = write(fn, "\0\0\0\0\0\0\0\0\0\0\0\0", bnulls);
672: ASSERT(ret > 0, "BAD WRITE genbrk", "", ret);
673: sleep(1);
674: ret = ioctl(fn, TIOCCBRK, STBNULL);
675: DEBUG(5, "break ioctl ret %d\n", ret);
676: #endif
677: DEBUG(4, "ioctl 1 second break\n", STBNULL);
678: #else
679: struct sgttyb ttbuf;
680: register int sospeed;
681:
682: ret = ioctl(fn, TIOCGETP, &ttbuf);
683: sospeed = ttbuf.sg_ospeed;
684: ttbuf.sg_ospeed = BSPEED;
685: ret = ioctl(fn, TIOCSETP, &ttbuf);
686: ret = write(fn, "\0\0\0\0\0\0\0\0\0\0\0\0", bnulls);
687: ASSERT(ret > 0, "BAD WRITE genbrk", "", ret);
688: ttbuf.sg_ospeed = sospeed;
689: ret = ioctl(fn, TIOCSETP, &ttbuf);
690: ret = write(fn, "@", 1);
691: ASSERT(ret > 0, "BAD WRITE genbrk", "", ret);
692: DEBUG(4, "sent BREAK nulls - %d\n", bnulls);
693: #endif
694: #endif
695: }
696:
697:
698: /***
699: * notin(sh, lg) check for occurrence of substring "sh"
700: * char *sh, *lg;
701: *
702: * return codes:
703: * 0 - found the string
704: * 1 - not in the string
705: */
706:
707: notin(sh, lg)
708: register char *sh, *lg;
709: {
710: while (*lg != '\0') {
711: /* Dave Martingale: permit wild cards in 'expect' */
712: if (wprefix(sh, lg))
713: return(0);
714: else
715: lg++;
716: }
717: return(1);
718: }
719:
720:
721: /*******
722: * ifdate(s)
723: * char *s;
724: *
725: * ittvax!swatt
726: * Allow multiple date specifications separated by '|'.
727: * Calls ifadate, formerly "ifdate".
728: *
729: * return codes:
730: * see ifadate
731: */
732:
733: ifdate(s)
734: char *s;
735: {
736: register char *p;
737: register int ret;
738:
739: for (p = s; p && (*p == '|' ? *++p : *p); p = index(p, '|'))
740: if (ret = ifadate(p))
741: return(ret);
742: return(0);
743: }
744:
745:
746: /*******
747: * ifadate(s)
748: * char *s;
749: *
750: * ifadate - this routine will check a string (s)
751: * like "MoTu0800-1730" to see if the present
752: * time is within the given limits.
753: * SIDE EFFECT - Retrytime is set
754: *
755: * String alternatives:
756: * Wk - Mo thru Fr
757: * zero or one time means all day
758: * Any - any day
759: *
760: * return codes:
761: * 0 - not within limits
762: * 1 - within limits
763: */
764:
765: ifadate(s)
766: char *s;
767: {
768: static char *days[]={
769: "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa", 0
770: };
771: time_t clock;
772: int rtime;
773: int i, tl, th, tn, flag, dayok=0;
774: struct tm *localtime();
775: struct tm *tp;
776: char *index();
777: char *p;
778:
779: /* pick up retry time for failures */
780: /* global variable Retrytime is set here */
781: if ((p = index(s, ',')) == NULL) {
782: Retrytime = RETRYTIME;
783: }
784: else {
785: i = sscanf(p+1, "%d", &rtime);
786: if (i < 1 || rtime < 5)
787: rtime = 5;
788: Retrytime = rtime * 60;
789: }
790:
791: time(&clock);
792: tp = localtime(&clock);
793: while (isalpha(*s)) {
794: for (i = 0; days[i]; i++) {
795: if (prefix(days[i], s))
796: if (tp->tm_wday == i)
797: dayok = 1;
798: }
799:
800: if (prefix("Wk", s))
801: if (tp->tm_wday >= 1 && tp->tm_wday <= 5)
802: dayok = 1;
803: if (prefix("Any", s))
804: dayok = 1;
805: s++;
806: }
807:
808: if (dayok == 0)
809: return(0);
810: i = sscanf(s, "%d-%d", &tl, &th);
811: tn = tp->tm_hour * 100 + tp->tm_min;
812: if (i < 2)
813: return(1);
814: if (th < tl)
815: flag = 0; /* set up for crossover 2400 test */
816: else
817: flag = 1;
818: if ((tn >= tl && tn <= th)
819: || (tn >= th && tn <= tl)) /* test for crossover 2400 */
820: return(flag);
821: else
822: return(!flag);
823: }
824:
825:
826: /***
827: * char *
828: * lastc(s) return pointer to last character
829: * char *s;
830: *
831: */
832:
833: char *
834: lastc(s)
835: register char *s;
836: {
837: while (*s != '\0') s++;
838: return(s);
839: }
840:
841:
842: /***
843: * char *
844: * fdig(cp) find first digit in string
845: *
846: * return - pointer to first digit in string or end of string
847: */
848:
849: char *
850: fdig(cp)
851: register char *cp;
852: {
853: register char *c;
854:
855: for (c = cp; *c; c++)
856: if (*c >= '0' && *c <= '9')
857: break;
858: return(c);
859: }
860:
861:
862: /*
863: * Compare strings: s1>s2: >0 s1==s2: 0 s1<s2: <0
864: * Strings are compared as if they contain all capital letters.
865: */
866:
867: snccmp(s1, s2)
868: register char *s1, *s2;
869: {
870: char c1, c2;
871:
872: if (islower(*s1)) c1 = toupper(*s1);
873: else c1 = *s1;
874: if (islower(*s2)) c2 = toupper(*s2);
875: else c2 = *s2;
876:
877: while (c1 == c2) {
878: if (*s1++=='\0')
879: return(0);
880: s2++;
881: if (islower(*s1)) c1 = toupper(*s1);
882: else c1 = *s1;
883: if (islower(*s2)) c2 = toupper(*s2);
884: else c2 = *s2;
885: }
886: return(c1 - c2);
887: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.