1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * NL7C (Network Layer 7 Cache) as part of SOCKFS provides an in-kernel
28 * gateway cache for the request/response message based L7 protocol HTTP
29 * (Hypertext Transfer Protocol, see HTTP/1.1 RFC2616) in a semantically
30 * transparent manner.
31 *
32 * Neither the requesting user agent (client, e.g. web browser) nor the
33 * origin server (e.g. webserver) that provided the response cached by
34 * NL7C are impacted in any way.
35 *
36 * Note, currently NL7C only processes HTTP messages via the embedded
37 * URI of scheme http (not https nor any other), additional scheme are
38 * intended to be supported as is practical such that much of the NL7C
39 * framework may appear more general purpose then would be needed just
40 * for an HTTP gateway cache.
41 *
42 * NL7C replaces NCA (Network Cache and Accelerator) and in the future
43 * NCAS (NCA/SSL).
44 *
45 * Further, NL7C uses all NCA configuration files, see "/etc/nca/", the
46 * NCA socket API, "AF_NCA", and "ndd /dev/nca" for backwards compatibility.
47 */
48
49 #include <sys/systm.h>
50 #include <sys/strsun.h>
51 #include <sys/strsubr.h>
52 #include <inet/common.h>
53 #include <inet/led.h>
54 #include <inet/mi.h>
55 #include <netinet/in.h>
56 #include <fs/sockfs/nl7c.h>
57 #include <fs/sockfs/nl7curi.h>
58 #include <fs/sockfs/socktpi.h>
59
60 #include <inet/nca/ncadoorhdr.h>
61 #include <inet/nca/ncalogd.h>
62 #include <inet/nca/ncandd.h>
63
64 #include <sys/promif.h>
65
66 /*
67 * NL7C, NCA, NL7C logger enabled:
68 */
69
70 boolean_t nl7c_enabled = B_FALSE;
71
72 boolean_t nl7c_logd_enabled = B_FALSE;
73 boolean_t nl7c_logd_started = B_FALSE;
74 boolean_t nl7c_logd_cycle = B_TRUE;
75
76 /*
77 * Some externs:
78 */
79
80 extern int inet_pton(int, char *, void *);
81
82 extern void nl7c_uri_init(void);
83 extern boolean_t nl7c_logd_init(int, caddr_t *);
84 extern void nl7c_nca_init(void);
85
86 /*
87 * nl7c_addr_t - a singly linked grounded list, pointed to by *nl7caddrs,
88 * constructed at init time by parsing "/etc/nca/ncaport.conf".
89 *
90 * This list is searched at bind(3SOCKET) time when an application doesn't
91 * explicitly set AF_NCA but instead uses AF_INET, if a match is found then
92 * the underlying socket is marked sti_nl7c_flags NL7C_ENABLED.
93 */
94
95 typedef struct nl7c_addr_s {
96 struct nl7c_addr_s *next; /* next entry */
97 sa_family_t family; /* addr type, only INET and INET6 */
98 uint16_t port; /* port */
99 union {
100 ipaddr_t v4; /* IPv4 address */
101 in6_addr_t v6; /* IPv6 address */
102 void *align; /* foce alignment */
103 } addr; /* address */
104
105 struct sonode *listener; /* listen()er's sonode */
106 boolean_t temp; /* temporary addr via add_addr() ? */
107 } nl7c_addr_t;
108
109 nl7c_addr_t *nl7caddrs = NULL;
110
111 /*
112 * Called for an NL7C_ENABLED listen()er socket for the nl7c_addr_t
113 * previously returned by nl7c_lookup_addr().
114 */
115
116 void
117 nl7c_listener_addr(void *arg, struct sonode *so)
118 {
119 nl7c_addr_t *p = (nl7c_addr_t *)arg;
120
121 if (p->listener == NULL)
122 p->listener = so;
123 SOTOTPI(so)->sti_nl7c_addr = arg;
124 }
125
126 struct sonode *
127 nl7c_addr2portso(void *arg)
128 {
129 nl7c_addr_t *p = (nl7c_addr_t *)arg;
130
131 return (p->listener);
132 }
133
134 void *
135 nl7c_lookup_addr(void *addr, t_uscalar_t addrlen)
136 {
137 struct sockaddr *sap = addr;
138 struct sockaddr_in *v4p = addr;
139 nl7c_addr_t *p = nl7caddrs;
140
141 if (sap->sa_family != AF_INET || addrlen != sizeof (*v4p)) {
142 /* Only support IPv4 */
143 return (B_FALSE);
144 }
145 while (p) {
146 if (sap->sa_family == p->family &&
147 v4p->sin_port == p->port &&
148 (v4p->sin_addr.s_addr == p->addr.v4 ||
149 p->addr.v4 == INADDR_ANY)) {
150 /* Match */
151 return (p);
152 }
153 p = p->next;
154 }
155 return (NULL);
156 }
157
158 void *
159 nl7c_add_addr(void *addr, t_uscalar_t addrlen)
160 {
161 struct sockaddr *sap = addr;
162 struct sockaddr_in *v4p = addr;
163 nl7c_addr_t *new = NULL;
164 nl7c_addr_t *old;
165 nl7c_addr_t *p;
166 boolean_t alloced;
167
168 if (sap->sa_family != AF_INET || addrlen != sizeof (*v4p)) {
169 /* Only support IPv4 */
170 return (NULL);
171 }
172 again:
173 p = nl7caddrs;
174 while (p) {
175 if (new == NULL && p->port == 0)
176 new = p;
177 if (sap->sa_family == p->family &&
178 v4p->sin_port == p->port &&
179 (v4p->sin_addr.s_addr == p->addr.v4 ||
180 p->addr.v4 == INADDR_ANY)) {
181 /* Match */
182 return (p);
183 }
184 p = p->next;
185 }
186 if (new == NULL) {
187 new = kmem_zalloc(sizeof (*new), KM_SLEEP);
188 alloced = B_TRUE;
189 } else
190 alloced = B_FALSE;
191
192 new->family = sap->sa_family;
193 new->port = v4p->sin_port;
194 new->addr.v4 = v4p->sin_addr.s_addr;
195 new->temp = B_TRUE;
196
197 if (alloced) {
198 old = nl7caddrs;
199 new->next = old;
200 if (atomic_cas_ptr(&nl7caddrs, old, new) != old) {
201 kmem_free(new, sizeof (*new));
202 goto again;
203 }
204 }
205
206 return (new);
207 }
208
209 boolean_t
210 nl7c_close_addr(struct sonode *so)
211 {
212 nl7c_addr_t *p = nl7caddrs;
213
214 while (p) {
215 if (p->listener == so) {
216 if (p->temp)
217 p->port = (uint16_t)-1;
218 p->listener = NULL;
219 return (B_TRUE);
220 }
221 p = p->next;
222 }
223 return (B_FALSE);
224 }
225
226 static void
227 nl7c_addr_add(nl7c_addr_t *p)
228 {
229 p->next = nl7caddrs;
230 nl7caddrs = p;
231 }
232
233 void
234 nl7c_mi_report_addr(mblk_t *mp)
235 {
236 ipaddr_t ip;
237 uint16_t port;
238 nl7c_addr_t *p = nl7caddrs;
239 struct sonode *so;
240 char addr[32];
241
242 (void) mi_mpprintf(mp, "Door Up-Call-Queue IPaddr:TCPport Listenning");
243 while (p) {
244 if (p->port != (uint16_t)-1) {
245 /* Don't report freed slots */
246 ip = ntohl(p->addr.v4);
247 port = ntohs(p->port);
248
249 if (ip == INADDR_ANY) {
250 (void) strcpy(addr, "*");
251 } else {
252 int a1 = (ip >> 24) & 0xFF;
253 int a2 = (ip >> 16) & 0xFF;
254 int a3 = (ip >> 8) & 0xFF;
255 int a4 = ip & 0xFF;
256
257 (void) mi_sprintf(addr, "%d.%d.%d.%d",
258 a1, a2, a3, a4);
259 }
260 so = p->listener;
261 (void) mi_mpprintf(mp, "%p %s:%d %d",
262 so ? (void *)strvp2wq(SOTOV(so)) : NULL,
263 addr, port, p->listener ? 1 : 0);
264 }
265 p = p->next;
266 }
267 }
268
269 /*
270 * ASCII to unsigned.
271 *
272 * Note, it's assumed that *p is a valid zero byte terminated string.
273 */
274
275 static unsigned
276 atou(const char *p)
277 {
278 int c;
279 int v = 0;
280
281 /* Shift and add digit by digit */
282 while ((c = *p++) != NULL && isdigit(c)) {
283 v *= 10;
284 v += c - '0';
285 }
286 return (v);
287 }
288
289 /*
290 * strdup(), yet another strdup() in the kernel.
291 */
292
293 static char *
294 strdup(char *s)
295 {
296 int len = strlen(s) + 1;
297 char *ret = kmem_alloc(len, KM_SLEEP);
298
299 bcopy(s, ret, len);
300
301 return (ret);
302 }
303
304 /*
305 * Inet ASCII to binary.
306 *
307 * Note, it's assumed that *s is a valid zero byte terminated string, and
308 * that *p is a zero initialized struct (this is important as the value of
309 * INADDR_ANY and IN6ADDR_ANY is zero).
310 */
311
312 static int
313 inet_atob(char *s, nl7c_addr_t *p)
314 {
315 if (strcmp(s, "*") == 0) {
316 /* INADDR_ANY */
317 p->family = AF_INET;
318 return (0);
319 }
320 if (strcmp(s, "::") == 0) {
321 /* IN6ADDR_ANY */
322 p->family = AF_INET6;
323 return (0);
324 }
325 /* IPv4 address ? */
326 if (inet_pton(AF_INET, s, &p->addr.v4) != 1) {
327 /* Nop, IPv6 address ? */
328 if (inet_pton(AF_INET6, s, &p->addr.v6) != 1) {
329 /* Nop, return error */
330 return (1);
331 }
332 p->family = AF_INET6;
333 } else {
334 p->family = AF_INET;
335 p->addr.v4 = ntohl(p->addr.v4);
336 }
337 return (0);
338 }
339
340 /*
341 * Open and read each line from "/etc/nca/ncaport.conf", the syntax of a
342 * ncaport.conf file line is:
343 *
344 * ncaport=IPaddr/Port[/Proxy]
345 *
346 * Where:
347 *
348 * ncaport - the only token recognized.
349 *
350 * IPaddr - an IPv4 numeric dot address (e.g. 192.168.84.71) or '*' for
351 * INADDR_ANY, or an IPv6 numeric address or "::" for IN6ADDR_ANY.
352 *
353 * / - IPaddr/Port separator.
354 *
355 * Port - a TCP decimal port number.
356 *
357 * Note, all other lines will be ignored.
358 */
359
360 static void
361 ncaportconf_read(void)
362 {
363 int ret;
364 struct vnode *vp;
365 char c;
366 ssize_t resid;
367 char buf[1024];
368 char *ebp = &buf[sizeof (buf)];
369 char *bp = ebp;
370 offset_t off = 0;
371 enum parse_e {START, TOK, ADDR, PORT, EOL} parse = START;
372 nl7c_addr_t *addrp = NULL;
373 char *ncaport = "ncaport";
374 char string[] = "XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX";
375 char *stringp;
376 char *tok;
377 char *portconf = "/etc/nca/ncaport.conf";
378
379 ret = vn_open(portconf, UIO_SYSSPACE, FREAD, 0, &vp, 0, 0);
380 if (ret == ENOENT) {
381 /* No portconf file, nothing to do */
382 return;
383 }
384 if (ret != 0) {
385 /* Error of some sort, tell'm about it */
386 cmn_err(CE_WARN, "%s: open error %d", portconf, ret);
387 return;
388 }
389 /*
390 * Read portconf one buf[] at a time, parse one char at a time.
391 */
392 for (;;) {
393 if (bp == ebp) {
394 /* Nothing left in buf[], read another */
395 ret = vn_rdwr(UIO_READ, vp, buf, sizeof (buf), off,
396 UIO_SYSSPACE, 0, (rlim64_t)0, CRED(), &resid);
397 if (ret != 0) {
398 /* Error of some sort, tell'm about it */
399 cmn_err(CE_WARN, "%s: read error %d",
400 portconf, ret);
401 break;
402 }
403 if (resid == sizeof (buf)) {
404 /* EOF, done */
405 break;
406 }
407 /* Initilize per buf[] state */
408 bp = buf;
409 ebp = &buf[sizeof (buf) - resid];
410 off += sizeof (buf) - resid;
411 }
412 c = *bp++;
413 switch (parse) {
414 case START:
415 /* Initilize all per file line state */
416 if (addrp == NULL) {
417 addrp = kmem_zalloc(sizeof (*addrp),
418 KM_NOSLEEP);
419 }
420 tok = ncaport;
421 stringp = string;
422 parse = TOK;
423 /*FALLTHROUGH*/
424 case TOK:
425 if (c == '#') {
426 /* Comment through end of line */
427 parse = EOL;
428 break;
429 }
430 if (isalpha(c)) {
431 if (c != *tok++) {
432 /* Only know one token, skip */
433 parse = EOL;
434 }
435 } else if (c == '=') {
436 if (*tok != NULL) {
437 /* Only know one token, skip */
438 parse = EOL;
439 break;
440 }
441 parse = ADDR;
442 } else if (c == '\n') {
443 /* Found EOL, empty line, next line */
444 parse = START;
445 } else {
446 /* Unexpected char, skip */
447 parse = EOL;
448 }
449 break;
450
451 case ADDR:
452 if (c == '/') {
453 /* addr/port separator, end of addr */
454 *stringp = NULL;
455 if (inet_atob(string, addrp)) {
456 /* Bad addr, skip */
457 parse = EOL;
458 } else {
459 stringp = string;
460 parse = PORT;
461 }
462 } else {
463 /* Save char to string */
464 if (stringp ==
465 &string[sizeof (string) - 1]) {
466 /* Would overflow, skip */
467 parse = EOL;
468 } else {
469 /* Copy IP addr char */
470 *stringp++ = c;
471 }
472 }
473 break;
474
475 case PORT:
476 if (isdigit(c)) {
477 /* Save char to string */
478 if (stringp ==
479 &string[sizeof (string) - 1]) {
480 /* Would overflow, skip */
481 parse = EOL;
482 } else {
483 /* Copy port digit char */
484 *stringp++ = c;
485 }
486 break;
487 } else if (c == '#' || isspace(c)) {
488 /* End of port number, convert */
489 *stringp = NULL;
490 addrp->port = ntohs(atou(string));
491
492 /* End of parse, add entry */
493 nl7c_addr_add(addrp);
494 addrp = NULL;
495 parse = EOL;
496 } else {
497 /* Unrecognized char, skip */
498 parse = EOL;
499 break;
500 }
501 if (c == '\n') {
502 /* Found EOL, start on next line */
503 parse = START;
504 }
505 break;
506
507 case EOL:
508 if (c == '\n') {
509 /* Found EOL, start on next line */
510 parse = START;
511 }
512 break;
513 }
514
515 }
516 if (addrp != NULL) {
517 kmem_free(addrp, sizeof (*addrp));
518 }
519 (void) VOP_CLOSE(vp, FREAD, 1, (offset_t)0, CRED(), NULL);
520 VN_RELE(vp);
521 }
522
523 /*
524 * Open and read each line from "/etc/nca/ncakmod.conf" and parse looking
525 * for the NCA enabled, the syntax is: status=enabled, all other lines will
526 * be ignored.
527 */
528
529 static void
530 ncakmodconf_read(void)
531 {
532 int ret;
533 struct vnode *vp;
534 char c;
535 ssize_t resid;
536 char buf[1024];
537 char *ebp = &buf[sizeof (buf)];
538 char *bp = ebp;
539 offset_t off = 0;
540 enum parse_e {START, TOK, EOL} parse = START;
541 char *status = "status=enabled";
542 char *tok;
543 char *ncakmod = "/etc/nca/ncakmod.conf";
544
545 ret = vn_open(ncakmod, UIO_SYSSPACE, FREAD, 0, &vp, 0, 0);
546 if (ret == ENOENT) {
547 /* No ncakmod file, nothing to do */
548 return;
549 }
550 if (ret != 0) {
551 /* Error of some sort, tell'm about it */
552 cmn_err(CE_WARN, "%s: open error %d", status, ret);
553 return;
554 }
555 /*
556 * Read ncakmod one buf[] at a time, parse one char at a time.
557 */
558 for (;;) {
559 if (bp == ebp) {
560 /* Nothing left in buf[], read another */
561 ret = vn_rdwr(UIO_READ, vp, buf, sizeof (buf), off,
562 UIO_SYSSPACE, 0, (rlim64_t)0, CRED(), &resid);
563 if (ret != 0) {
564 /* Error of some sort, tell'm about it */
565 cmn_err(CE_WARN, "%s: read error %d",
566 status, ret);
567 break;
568 }
569 if (resid == sizeof (buf)) {
570 /* EOF, done */
571 break;
572 }
573 /* Initilize per buf[] state */
574 bp = buf;
575 ebp = &buf[sizeof (buf) - resid];
576 off += sizeof (buf) - resid;
577 }
578 c = *bp++;
579 switch (parse) {
580 case START:
581 /* Initilize all per file line state */
582 tok = status;
583 parse = TOK;
584 /*FALLTHROUGH*/
585 case TOK:
586 if (c == '#') {
587 /* Comment through end of line */
588 parse = EOL;
589 break;
590 }
591 if (isalpha(c) || c == '=') {
592 if (c != *tok++) {
593 /* Only know one token, skip */
594 parse = EOL;
595 }
596 } else if (c == '\n') {
597 /*
598 * Found EOL, if tok found done,
599 * else start on next-line.
600 */
601 if (*tok == NULL) {
602 nl7c_enabled = B_TRUE;
603 goto done;
604 }
605 parse = START;
606 } else {
607 /* Unexpected char, skip */
608 parse = EOL;
609 }
610 break;
611
612 case EOL:
613 if (c == '\n') {
614 /* Found EOL, start on next line */
615 parse = START;
616 }
617 break;
618 }
619
620 }
621 done:
622 (void) VOP_CLOSE(vp, FREAD, 1, (offset_t)0, CRED(), NULL);
623 VN_RELE(vp);
624 }
625
626 /*
627 * Open and read each line from "/etc/nca/ncalogd.conf" and parse for
628 * the tokens and token text (i.e. key and value ncalogd.conf(4)):
629 *
630 * status=enabled
631 *
632 * logd_file_size=[0-9]+
633 *
634 * logd_file_name=["]filename( filename)*["]
635 */
636
637 static int file_size = 1000000;
638 static caddr_t fnv[NCA_FIOV_SZ];
639
640 static void
641 ncalogdconf_read(void)
642 {
643 int ret;
644 struct vnode *vp;
645 char c;
646 int sz;
647 ssize_t resid;
648 char buf[1024];
649 char *ebp = &buf[sizeof (buf)];
650 char *bp = ebp;
651 offset_t off = 0;
652 enum parse_e {START, TOK, TEXT, EOL} parse = START;
653 char *tokstatus = "status\0enabled";
654 char *toksize = "logd_file_size";
655 char *tokfile = "logd_path_name";
656 char *tokstatusp;
657 char *toksizep;
658 char *tokfilep;
659 char *tok;
660 int tokdelim = 0;
661 char *ncalogd = "/etc/nca/ncalogd.conf";
662 char *ncadeflog = "/var/nca/log";
663 char file[TYPICALMAXPATHLEN] = {0};
664 char *fp = file;
665 caddr_t *fnvp = fnv;
666
667 ret = vn_open(ncalogd, UIO_SYSSPACE, FREAD, 0, &vp, 0, 0);
668 if (ret == ENOENT) {
669 /* No ncalogd file, nothing to do */
670 return;
671 }
672 if (ret != 0) {
673 /* Error of some sort, tell'm about it */
674 cmn_err(CE_WARN, "ncalogdconf_read: %s: open error(%d).",
675 ncalogd, ret);
676 return;
677 }
678 /*
679 * Read ncalogd.conf one buf[] at a time, parse one char at a time.
680 */
681 for (;;) {
682 if (bp == ebp) {
683 /* Nothing left in buf[], read another */
684 ret = vn_rdwr(UIO_READ, vp, buf, sizeof (buf), off,
685 UIO_SYSSPACE, 0, (rlim64_t)0, CRED(), &resid);
686 if (ret != 0) {
687 /* Error of some sort, tell'm about it */
688 cmn_err(CE_WARN, "%s: read error %d",
689 ncalogd, ret);
690 break;
691 }
692 if (resid == sizeof (buf)) {
693 /* EOF, done */
694 break;
695 }
696 /* Initilize per buf[] state */
697 bp = buf;
698 ebp = &buf[sizeof (buf) - resid];
699 off += sizeof (buf) - resid;
700 }
701 c = *bp++;
702 switch (parse) {
703 case START:
704 /* Initilize all per file line state */
705 tokstatusp = tokstatus;
706 toksizep = toksize;
707 tokfilep = tokfile;
708 tok = NULL;
709 parse = TOK;
710 sz = 0;
711 /*FALLTHROUGH*/
712 case TOK:
713 if (isalpha(c) || c == '_') {
714 /*
715 * Found a valid tok char, if matches
716 * any of the tokens continue else NULL
717 * then string pointer.
718 */
719 if (tokstatusp != NULL && c != *tokstatusp++)
720 tokstatusp = NULL;
721 if (toksizep != NULL && c != *toksizep++)
722 toksizep = NULL;
723 if (tokfilep != NULL && c != *tokfilep++)
724 tokfilep = NULL;
725
726 if (tokstatusp == NULL &&
727 toksizep == NULL &&
728 tokfilep == NULL) {
729 /*
730 * All tok string pointers are NULL
731 * so skip rest of line.
732 */
733 parse = EOL;
734 }
735 } else if (c == '=') {
736 /*
737 * Found tok separator, if tok found get
738 * tok text, else skip rest of line.
739 */
740 if (tokstatusp != NULL && *tokstatusp == NULL)
741 tok = tokstatus;
742 else if (toksizep != NULL && *toksizep == NULL)
743 tok = toksize;
744 else if (tokfilep != NULL && *tokfilep == NULL)
745 tok = tokfile;
746 if (tok != NULL)
747 parse = TEXT;
748 else
749 parse = EOL;
750 } else if (c == '\n') {
751 /* Found EOL, start on next line */
752 parse = START;
753 } else {
754 /* Comment or unknown char, skip rest of line */
755 parse = EOL;
756 }
757 break;
758 case TEXT:
759 if (c == '\n') {
760 /*
761 * Found EOL, finish up tok text processing
762 * (if any) and start on next line.
763 */
764 if (tok == tokstatus) {
765 if (*++tokstatusp == NULL)
766 nl7c_logd_enabled = B_TRUE;
767 } else if (tok == toksize) {
768 file_size = sz;
769 } else if (tok == tokfile) {
770 if (tokdelim == 0) {
771 /* Non delimited path name */
772 *fnvp++ = strdup(file);
773 } else if (fp != file) {
774 /* No closing delimiter */
775 /*EMPTY*/;
776 }
777 }
778 parse = START;
779 } else if (tok == tokstatus) {
780 if (! isalpha(c) || *++tokstatusp == NULL ||
781 c != *tokstatusp) {
782 /* Not enabled, skip line */
783 parse = EOL;
784 }
785 } else if (tok == toksize) {
786 if (isdigit(c)) {
787 sz *= 10;
788 sz += c - '0';
789 } else {
790 /* Not a decimal digit, skip line */
791 parse = EOL;
792 }
793 } else {
794 /* File name */
795 if (c == '"' && tokdelim++ == 0) {
796 /* Opening delimiter, skip */
797 /*EMPTY*/;
798 } else if (c == '"' || c == ' ') {
799 /* List delim or filename separator */
800 *fnvp++ = strdup(file);
801 fp = file;
802 } else if (fp < &file[sizeof (file) - 1]) {
803 /* Filename char */
804 *fp++ = c;
805 } else {
806 /* Filename to long, skip line */
807 parse = EOL;
808 }
809 }
810 break;
811
812 case EOL:
813 if (c == '\n') {
814 /* Found EOL, start on next line */
815 parse = START;
816 }
817 break;
818 }
819
820 }
821 done:
822 (void) VOP_CLOSE(vp, FREAD, 1, (offset_t)0, CRED(), NULL);
823 VN_RELE(vp);
824
825 if (nl7c_logd_enabled) {
826 if (fnvp == fnv) {
827 /*
828 * No logfile was specified and found so
829 * so use defualt NCA log file path.
830 */
831 *fnvp++ = strdup(ncadeflog);
832 }
833 if (fnvp < &fnv[NCA_FIOV_SZ]) {
834 /* NULL terminate list */
835 *fnvp = NULL;
836 }
837 }
838 }
839
840 void
841 nl7clogd_startup(void)
842 {
843 static kmutex_t startup;
844
845 /*
846 * Called on the first log() attempt, have to wait until then to
847 * initialize logd as at logdconf_read() the root fs is read-only.
848 */
849 mutex_enter(&startup);
850 if (nl7c_logd_started) {
851 /* Lost the race, nothing todo */
852 mutex_exit(&startup);
853 return;
854 }
855 nl7c_logd_started = B_TRUE;
856 if (! nl7c_logd_init(file_size, fnv)) {
857 /* Failure, disable logging */
858 nl7c_logd_enabled = B_FALSE;
859 cmn_err(CE_WARN, "nl7clogd_startup: failed, disabling loggin");
860 mutex_exit(&startup);
861 return;
862 }
863 mutex_exit(&startup);
864 }
865
866
867 void
868 nl7c_startup()
869 {
870 /*
871 * Open, read, and parse the NCA logd configuration file,
872 * then initialize URI processing and NCA compat.
873 */
874 ncalogdconf_read();
875 nl7c_uri_init();
876 nl7c_nca_init();
877 }
878
879 void
880 nl7c_init()
881 {
882 /* Open, read, and parse the NCA kmod configuration file */
883 ncakmodconf_read();
884
885 if (nl7c_enabled) {
886 /*
887 * NL7C is enabled so open, read, and parse
888 * the NCA address/port configuration file
889 * and call startup() to finish config/init.
890 */
891 ncaportconf_read();
892 nl7c_startup();
893 }
894 }
895
896 /*
897 * The main processing function called by accept() on a newly created
898 * socket prior to returning it to the caller of accept().
899 *
900 * Here data is read from the socket until a completed L7 request parse
901 * is completed. Data will be read in the context of the user thread
902 * which called accept(), when parse has been completed either B_TRUE
903 * or B_FALSE will be returned.
904 *
905 * If NL7C successfully process the L7 protocol request, i.e. generates
906 * a response, B_TRUE will be returned.
907 *
908 * Else, B_FALSE will be returned if NL7C can't process the request:
909 *
910 * 1) Couldn't locate a URI within the request.
911 *
912 * 2) URI scheme not reqcognized.
913 *
914 * 3) A request which can't be processed.
915 *
916 * 4) A request which could be processed but NL7C dosen't currently have
917 * the response data. In which case NL7C will parse the returned response
918 * from the application for possible caching for subsequent request(s).
919 */
920
921 volatile uint64_t nl7c_proc_cnt = 0;
922 volatile uint64_t nl7c_proc_error = 0;
923 volatile uint64_t nl7c_proc_ETIME = 0;
924 volatile uint64_t nl7c_proc_again = 0;
925 volatile uint64_t nl7c_proc_next = 0;
926 volatile uint64_t nl7c_proc_rcv = 0;
927 volatile uint64_t nl7c_proc_noLRI = 0;
928 volatile uint64_t nl7c_proc_nodata = 0;
929 volatile uint64_t nl7c_proc_parse = 0;
930
931 boolean_t
932 nl7c_process(struct sonode *so, boolean_t nonblocking)
933 {
934 vnode_t *vp = SOTOV(so);
935 sotpi_info_t *sti = SOTOTPI(so);
936 mblk_t *rmp = sti->sti_nl7c_rcv_mp;
937 clock_t timout;
938 rval_t rval;
939 uchar_t pri;
940 int pflag;
941 int error;
942 boolean_t more;
943 boolean_t ret = B_FALSE;
944 boolean_t first = B_TRUE;
945 boolean_t pollin = (sti->sti_nl7c_flags & NL7C_POLLIN);
946
947 nl7c_proc_cnt++;
948
949 /* Caller has so_lock enter()ed */
950 error = so_lock_read_intr(so, nonblocking ? FNDELAY|FNONBLOCK : 0);
951 if (error) {
952 /* Couldn't read lock, pass on this socket */
953 sti->sti_nl7c_flags = 0;
954 nl7c_proc_noLRI++;
955 return (B_FALSE);
956 }
957 /* Exit so_lock for now, will be reenter()ed prior to return */
958 mutex_exit(&so->so_lock);
959
960 if (pollin)
961 sti->sti_nl7c_flags &= ~NL7C_POLLIN;
962
963 /* Initialize some kstrgetmsg() constants */
964 pflag = MSG_ANY | MSG_DELAYERROR;
965 pri = 0;
966 if (nonblocking) {
967 /* Non blocking so don't block */
968 timout = 0;
969 } else if (sti->sti_nl7c_flags & NL7C_SOPERSIST) {
970 /* 2nd or more time(s) here so use keep-alive value */
971 timout = nca_http_keep_alive_timeout;
972 } else {
973 /* 1st time here so use connection value */
974 timout = nca_http_timeout;
975 }
976
977 rval.r_vals = 0;
978 do {
979 /*
980 * First time through, if no data left over from a previous
981 * kstrgetmsg() then try to get some, else just process it.
982 *
983 * Thereafter, rmp = NULL after the successful kstrgetmsg()
984 * so try to get some new data and append to list (i.e. until
985 * enough fragments are collected for a successful parse).
986 */
987 if (rmp == NULL) {
988
989 error = kstrgetmsg(vp, &rmp, NULL, &pri, &pflag,
990 timout, &rval);
991 if (error) {
992 if (error == ETIME) {
993 /* Timeout */
994 nl7c_proc_ETIME++;
995 } else if (error != EWOULDBLOCK) {
996 /* Error of some sort */
997 nl7c_proc_error++;
998 rval.r_v.r_v2 = error;
999 sti->sti_nl7c_flags = 0;
1000 break;
1001 }
1002 error = 0;
1003 }
1004 if (rmp != NULL) {
1005 mblk_t *mp = sti->sti_nl7c_rcv_mp;
1006
1007
1008 if (mp == NULL) {
1009 /* Just new data, common case */
1010 sti->sti_nl7c_rcv_mp = rmp;
1011 } else {
1012 /* Add new data to tail */
1013 while (mp->b_cont != NULL)
1014 mp = mp->b_cont;
1015 mp->b_cont = rmp;
1016 }
1017 }
1018 if (sti->sti_nl7c_rcv_mp == NULL) {
1019 /* No data */
1020 nl7c_proc_nodata++;
1021 if (timout > 0 || (first && pollin)) {
1022 /* Expected data so EOF */
1023 ret = B_TRUE;
1024 } else if (sti->sti_nl7c_flags &
1025 NL7C_SOPERSIST) {
1026 /* Persistent so just checking */
1027 ret = B_FALSE;
1028 }
1029 break;
1030 }
1031 rmp = NULL;
1032 }
1033 first = B_FALSE;
1034 again:
1035 nl7c_proc_parse++;
1036
1037 more = nl7c_parse(so, nonblocking, &ret);
1038
1039 if (ret == B_TRUE && (sti->sti_nl7c_flags & NL7C_SOPERSIST)) {
1040 /*
1041 * Parse complete, cache hit, response on its way,
1042 * socket is persistent so try to process the next
1043 * request.
1044 */
1045 if (nonblocking) {
1046 ret = B_FALSE;
1047 break;
1048 }
1049 if (sti->sti_nl7c_rcv_mp) {
1050 /* More recv-side data, pipelined */
1051 nl7c_proc_again++;
1052 goto again;
1053 }
1054 nl7c_proc_next++;
1055 if (nonblocking)
1056 timout = 0;
1057 else
1058 timout = nca_http_keep_alive_timeout;
1059
1060 more = B_TRUE;
1061 }
1062
1063 } while (more);
1064
1065 if (sti->sti_nl7c_rcv_mp) {
1066 nl7c_proc_rcv++;
1067 }
1068 sti->sti_nl7c_rcv_rval = rval.r_vals;
1069 /* Renter so_lock, caller called with it enter()ed */
1070 mutex_enter(&so->so_lock);
1071 so_unlock_read(so);
1072
1073 return (ret);
1074 }