![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to phys.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|
Return to phys.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mpd / src |
1.1 misho 1:
2: /*
3: * phys.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 "msg.h"
12: #include "link.h"
13: #include "devices.h"
14: #include "util.h"
15:
16: #include <netgraph/ng_tee.h>
17:
18: /*
19: * The physical layer has four states: DOWN, OPENING, CLOSING, and UP.
20: * Each device type must implement this set of standard methods:
21: *
22: * init Called once for each device to initialize it.
23: * open Called in the DOWN state to initiate connection.
24: * Device should eventually call PhysUp() or PhysDown().
25: * close Called in the OPENING or UP states.
26: * Device should eventually call PhysDown().
27: * update Called when LCP reaches the UP state. Device should
28: * update its configuration based on LCP negotiated
29: * settings, if necessary.
30: * showstat Display device statistics.
31: *
32: * The device should generate UP and DOWN events in response to OPEN
33: * and CLOSE events. If the device goes down suddenly after being OPEN,
34: * the close method will not be explicitly called to clean up.
35: *
36: * All device types must support MRU's of at least 1500.
37: *
38: * Each device is responsible for connecting the appropriate netgraph
39: * node to the PPP node when the link comes up, and disconnecting it
40: * when the link goes down (or is closed). The device should NOT send
41: * any NGM_PPP_SET_CONFIG messsages to the ppp node.
42: */
43:
44: /*
45: * INTERNAL FUNCTIONS
46: */
47:
48: static void PhysMsg(int type, void *arg);
49:
50: /*
51: * GLOBAL VARIABLES
52: */
53:
1.1.1.3 misho 54: const struct phystype *gPhysTypes[] = {
1.1 misho 55: #define _WANT_DEVICE_TYPES
56: #include "devices.h"
57: NULL,
58: };
59:
60: const char *gPhysStateNames[] = {
61: "DOWN",
62: "CONNECTING",
63: "READY",
64: "UP",
65: };
66:
67: int
68: PhysInit(Link l)
69: {
70: MsgRegister(&l->pmsgs, PhysMsg);
71:
72: /* Initialize type specific stuff */
73: if ((l->type->init)(l) < 0) {
74: Log(LG_ERR, ("[%s] type \"%s\" initialization failed",
75: l->name, l->type->name));
76: l->type = NULL;
77: return (0);
78: }
79:
80: return (0);
81: }
82:
83: /*
84: * PhysInst()
85: */
86:
87: int
88: PhysInst(Link l, Link lt)
89: {
90: return ((l->type->inst)(l, lt));
91: }
92:
93: /*
94: * PhysOpenCmd()
95: */
96:
97: int
98: PhysOpenCmd(Context ctx)
99: {
100: if (ctx->lnk->tmpl)
101: Error("impossible to open template");
102: RecordLinkUpDownReason(NULL, ctx->lnk, 1, STR_MANUALLY, NULL);
103: PhysOpen(ctx->lnk);
104: return (0);
105: }
106:
107: /*
108: * PhysOpen()
109: */
110:
111: void
112: PhysOpen(Link l)
113: {
114: REF(l);
115: MsgSend(&l->pmsgs, MSG_OPEN, l);
116: }
117:
118: /*
119: * PhysCloseCmd()
120: */
121:
122: int
123: PhysCloseCmd(Context ctx)
124: {
125: if (ctx->lnk->tmpl)
126: Error("impossible to close template");
127: RecordLinkUpDownReason(NULL, ctx->lnk, 0, STR_MANUALLY, NULL);
128: PhysClose(ctx->lnk);
129: return (0);
130: }
131:
132: /*
133: * PhysClose()
134: */
135:
136: void
137: PhysClose(Link l)
138: {
139: REF(l);
140: MsgSend(&l->pmsgs, MSG_CLOSE, l);
141: }
142:
143: /*
144: * PhysUp()
145: */
146:
147: void
148: PhysUp(Link l)
149: {
150: Log(LG_PHYS2, ("[%s] device: UP event", l->name));
151: l->last_up = time(NULL);
152: if (!l->rep) {
153: LinkUp(l);
154: } else {
155: RepUp(l);
156: }
157: }
158:
159: /*
160: * PhysDown()
161: */
162:
163: void
164: PhysDown(Link l, const char *reason, const char *details)
165: {
166: Log(LG_PHYS2, ("[%s] device: DOWN event", l->name));
167: if (!l->rep) {
168: RecordLinkUpDownReason(NULL, l, 0, reason, details);
169: l->upReasonValid=0;
170: LinkDown(l);
171: LinkShutdownCheck(l, l->lcp.fsm.state);
172:
173: } else {
174: RepDown(l);
175: }
176: }
177:
178: /*
179: * PhysIncoming()
180: */
181:
182: void
183: PhysIncoming(Link l)
184: {
185: const char *rept;
186:
187: rept = LinkMatchAction(l, 1, NULL);
188: if (rept) {
189: if (strcmp(rept,"##DROP##") == 0) {
190: /* Action told we must drop this connection */
191: Log(LG_PHYS, ("[%s] Drop connection", l->name));
192: PhysClose(l);
193: return;
194: }
195: if (RepCreate(l, rept)) {
196: Log(LG_ERR, ("[%s] Repeater to \"%s\" creation error", l->name, rept));
197: PhysClose(l);
198: return;
199: }
200: }
201:
202: if (!l->rep) {
203: RecordLinkUpDownReason(NULL, l, 1, STR_INCOMING_CALL, NULL);
204: LinkOpen(l);
205: } else {
206: RepIncoming(l);
207: }
208: }
209:
210: /*
211: * PhysSetAccm()
212: */
213:
214: int
215: PhysSetAccm(Link l, uint32_t xmit, u_int32_t recv)
216: {
217: if (l->type && l->type->setaccm)
218: return (*l->type->setaccm)(l, xmit, recv);
219: else
220: return (0);
221: }
222:
223: /*
224: * PhysGetUpperHook()
225: */
226:
227: int
228: PhysGetUpperHook(Link l, char *path, char *hook)
229: {
230: if (!l->rep) {
231: snprintf(path, NG_PATHSIZ, "[%lx]:", (u_long)l->nodeID);
232: strcpy(hook, NG_TEE_HOOK_LEFT);
233: return 1;
234: } else {
235: return RepGetHook(l, path, hook);
236: }
237: return 0;
238: }
239:
240: /*
241: * PhysGetOriginate()
242: *
243: * This returns one of LINK_ORIGINATE_{UNKNOWN, LOCAL, REMOTE}
244: */
245:
246: int
247: PhysGetOriginate(Link l)
248: {
1.1.1.3 misho 249: const struct phystype *pt = l->type;
1.1 misho 250:
251: return((pt && pt->originate) ? (*pt->originate)(l) : LINK_ORIGINATE_UNKNOWN);
252: }
253:
254: /*
255: * PhysIsSync()
256: *
257: * This returns 1 if link is synchronous
258: */
259:
260: int
261: PhysIsSync(Link l)
262: {
1.1.1.3 misho 263: const struct phystype *pt = l->type;
1.1 misho 264:
265: return((pt && pt->issync) ? (*pt->issync)(l) : 0);
266: }
267:
268: /*
269: * PhysSetCalledNum()
270: */
271:
272: int
273: PhysSetCallingNum(Link l, char *buf)
274: {
1.1.1.3 misho 275: const struct phystype *pt = l->type;
1.1 misho 276:
277: if (pt && pt->setcallingnum)
278: return ((*pt->setcallingnum)(l, buf));
279: else
280: return (0);
281: }
282:
283: /*
284: * PhysSetCalledNum()
285: */
286:
287: int
288: PhysSetCalledNum(Link l, char *buf)
289: {
1.1.1.3 misho 290: const struct phystype *pt = l->type;
1.1 misho 291:
292: if (pt && pt->setcallednum)
293: return ((*pt->setcallednum)(l, buf));
294: else
295: return (0);
296: }
297:
298: /*
299: * PhysGetSelfName()
300: */
301:
302: int
303: PhysGetSelfName(Link l, char *buf, size_t buf_len)
304: {
1.1.1.3 misho 305: const struct phystype *pt = l->type;
1.1 misho 306:
307: buf[0] = 0;
308:
309: if (pt && pt->selfname)
310: return ((*pt->selfname)(l, buf, buf_len));
311: else
312: return (0);
313: }
314:
315: /*
316: * PhysGetPeerName()
317: */
318:
319: int
320: PhysGetPeerName(Link l, char *buf, size_t buf_len)
321: {
1.1.1.3 misho 322: const struct phystype *pt = l->type;
1.1 misho 323:
324: buf[0] = 0;
325:
326: if (pt && pt->peername)
327: return ((*pt->peername)(l, buf, buf_len));
328: else
329: return (0);
330: }
331:
332: /*
333: * PhysGetSelfAddr()
334: */
335:
336: int
337: PhysGetSelfAddr(Link l, char *buf, size_t buf_len)
338: {
1.1.1.3 misho 339: const struct phystype *pt = l->type;
1.1 misho 340:
341: buf[0] = 0;
342:
343: if (pt && pt->selfaddr)
344: return ((*pt->selfaddr)(l, buf, buf_len));
345: else
346: return (0);
347: }
348:
349: /*
350: * PhysGetPeerAddr()
351: */
352:
353: int
354: PhysGetPeerAddr(Link l, char *buf, size_t buf_len)
355: {
1.1.1.3 misho 356: const struct phystype *pt = l->type;
1.1 misho 357:
358: buf[0] = 0;
359:
360: if (pt && pt->peeraddr)
361: return ((*pt->peeraddr)(l, buf, buf_len));
362: else
363: return (0);
364: }
365:
366: /*
367: * PhysGetPeerPort()
368: */
369:
370: int
371: PhysGetPeerPort(Link l, char *buf, size_t buf_len)
372: {
1.1.1.3 misho 373: const struct phystype *pt = l->type;
1.1 misho 374:
375: buf[0] = 0;
376:
377: if (pt && pt->peerport)
378: return ((*pt->peerport)(l, buf, buf_len));
379: else
380: return (0);
381: }
382:
383: /*
384: * PhysGetPeerMacAddr()
385: */
386:
387: int
388: PhysGetPeerMacAddr(Link l, char *buf, size_t buf_len)
389: {
1.1.1.3 misho 390: const struct phystype *pt = l->type;
1.1 misho 391:
392: buf[0] = 0;
393:
394: if (pt && pt->peermacaddr)
395: return ((*pt->peermacaddr)(l, buf, buf_len));
396: else
397: return (0);
398: }
399:
400: /*
401: * PhysGetPeerIface()
402: */
403:
404: int
405: PhysGetPeerIface(Link l, char *buf, size_t buf_len)
406: {
1.1.1.3 misho 407: const struct phystype *pt = l->type;
1.1 misho 408:
409: buf[0] = 0;
410:
411: if (pt && pt->peeriface)
412: return ((*pt->peeriface)(l, buf, buf_len));
413: else
414: return (0);
415: }
416:
417: /*
418: * PhysGetCallingNum()
419: */
420:
421: int
422: PhysGetCallingNum(Link l, char *buf, size_t buf_len)
423: {
1.1.1.3 misho 424: const struct phystype *pt = l->type;
1.1 misho 425:
426: buf[0] = 0;
427:
428: if (pt) {
429: /* For untrusted peers use peeraddr as calling */
430: if (Enabled(&l->conf.options, LINK_CONF_PEER_AS_CALLING) && pt->peeraddr)
431: (*pt->peeraddr)(l, buf, buf_len);
432: else if (pt->callingnum)
433: (*pt->callingnum)(l, buf, buf_len);
434: if (Enabled(&l->conf.options, LINK_CONF_REPORT_MAC)) {
435: char tmp[64];
436: strlcat(buf, " / ", buf_len);
437: if (pt->peermacaddr) {
438: (*pt->peermacaddr)(l, tmp, sizeof(tmp));
439: strlcat(buf, tmp, buf_len);
440: }
441: strlcat(buf, " / ", buf_len);
442: if (pt->peeriface) {
443: (*pt->peeriface)(l, tmp, sizeof(tmp));
444: strlcat(buf, tmp, buf_len);
445: }
446: }
447: }
448: return (0);
449: }
450:
451: /*
452: * PhysGetCalledNum()
453: */
454:
455: int
456: PhysGetCalledNum(Link l, char *buf, size_t buf_len)
457: {
1.1.1.3 misho 458: const struct phystype *pt = l->type;
1.1 misho 459:
460: buf[0] = 0;
461:
462: if (pt && pt->callednum)
463: return ((*pt->callednum)(l, buf, buf_len));
464: else
465: return (0);
466: }
467:
468: /*
1.1.1.2 misho 469: * PhysGetMtu()
470: */
471:
472: u_short
473: PhysGetMtu(Link l, int conf)
474: {
1.1.1.3 misho 475: const struct phystype *pt = l->type;
1.1.1.2 misho 476:
477: if (pt) {
478: if (pt->getmtu)
479: return ((*pt->getmtu)(l, conf));
480: if (conf == 0) {
481: if (pt->mtu)
482: return (pt->mtu);
483: else
484: return (0);
485: } else
1.1.1.3.2.1! misho 486: return (l->conf.mtu ? l->conf.mtu : LCP_DEFAULT_MRU);
1.1.1.2 misho 487: } else
488: return (0);
489: }
490:
491: /*
492: * PhysGetMru()
493: */
494:
495: u_short
496: PhysGetMru(Link l, int conf)
497: {
1.1.1.3 misho 498: const struct phystype *pt = l->type;
1.1.1.2 misho 499:
500: if (pt) {
501: if (pt->getmru)
502: return ((*pt->getmru)(l, conf));
503: if (conf == 0) {
504: if (pt->mru)
505: return (pt->mru);
506: else
507: return (0);
508: } else
509: return (l->conf.mru);
510: } else
511: return (0);
512: }
513:
514: /*
1.1 misho 515: * PhysIsBusy()
516: *
517: * This returns 1 if link is busy
518: */
519:
520: int
521: PhysIsBusy(Link l)
522: {
523: return (l->die || l->rep || l->state != PHYS_STATE_DOWN ||
524: l->lcp.fsm.state != ST_INITIAL || l->lcp.auth.acct_thread != NULL ||
525: (l->tmpl && (l->children >= l->conf.max_children || gChildren >= gMaxChildren)));
526: }
527:
528: /*
529: * PhysShutdown()
530: */
531:
532: void
533: PhysShutdown(Link l)
534: {
1.1.1.3 misho 535: const struct phystype *pt = l->type;
1.1 misho 536:
537: MsgUnRegister(&l->pmsgs);
538:
539: if (pt && pt->shutdown)
540: (*pt->shutdown)(l);
541: }
542:
543: /*
544: * PhysSetDeviceType()
545: */
546:
547: void
548: PhysSetDeviceType(Link l, char *typename)
549: {
1.1.1.3 misho 550: const struct phystype *pt;
1.1 misho 551: int k;
552:
553: /* Make sure device type not already set */
554: if (l->type) {
555: Log(LG_ERR, ("[%s] device type already set to %s",
556: l->name, l->type->name));
557: return;
558: }
559:
560: /* Locate type */
561: for (k = 0; (pt = gPhysTypes[k]); k++) {
562: if (!strcmp(pt->name, typename))
563: break;
564: }
565: if (pt == NULL) {
566: Log(LG_ERR, ("[%s] device type \"%s\" unknown", l->name, typename));
567: return;
568: }
569: l->type = pt;
570:
571: /* Initialize type specific stuff */
572: if ((l->type->init)(l) < 0) {
573: Log(LG_ERR, ("[%s] type \"%s\" initialization failed",
574: l->name, l->type->name));
575: l->type = NULL;
576: return;
577: }
578: }
579:
580: /*
581: * PhysMsg()
582: */
583:
584: static void
585: PhysMsg(int type, void *arg)
586: {
587: Link const l = (Link)arg;
588:
589: if (l->dead) {
590: UNREF(l);
591: return;
592: }
1.1.1.3.2.1! misho 593: Log(LG_PHYS2, ("[%s] device: %s event in state %s",
! 594: l->name, MsgName(type), gPhysStateNames[l->state]));
1.1 misho 595: switch (type) {
596: case MSG_OPEN:
597: l->downReasonValid=0;
598: if (l->rep && l->state == PHYS_STATE_UP) {
599: PhysUp(l);
600: break;
601: }
1.1.1.3.2.1! misho 602: /* Redial may result in MSG_OPEN for just opened device */
! 603: if (l->state != PHYS_STATE_UP)
! 604: (*l->type->open)(l);
! 605: else
! 606: Log(LG_PHYS2, ("[%s] device: OPEN event ignored",
! 607: l->name));
1.1 misho 608: break;
609: case MSG_CLOSE:
610: (*l->type->close)(l);
611: break;
612: default:
613: assert(FALSE);
614: }
615: UNREF(l);
616: }
617:
618: /*
619: * PhysStat()
620: */
621:
622: int
1.1.1.3 misho 623: PhysStat(Context ctx, int ac, const char *const av[], const void *arg)
1.1 misho 624: {
625: Link const l = ctx->lnk;
626:
1.1.1.3 misho 627: (void)ac;
628: (void)av;
629: (void)arg;
630:
1.1 misho 631: Printf("Device '%s' (%s)\r\n", l->name, (l->tmpl)?"template":"instance");
632: Printf("\tType : %s\r\n", l->type->name);
633: if (!l->tmpl) {
634: Printf("\tState : %s\r\n", gPhysStateNames[l->state]);
635: if (l->state == PHYS_STATE_UP)
636: Printf("\tSession time : %ld seconds\r\n", (long int)(time(NULL) - l->last_up));
637: }
638:
639: if (l->type->showstat)
640: (*l->type->showstat)(ctx);
641: return 0;
642: }
643: