ipfw2 - Final whitespace cleanup
[dragonfly.git] / sys / net / libalias / alias_nbt.c
1 /*-
2  * Written by Atsushi Murai <amurai@spec.co.jp>
3  * Copyright (c) 1998, System Planning and Engineering Co.
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  *  TODO:
27  *       oClean up.
28  *       oConsidering for word alignment for other platform.
29  */
30
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD: src/sys/netinet/libalias/alias_nbt.c,v 1.20.6.1 2008/11/25 02:59:29 kensmith Exp $");
33
34 /*
35     alias_nbt.c performs special processing for NetBios over TCP/IP
36     sessions by UDP.
37
38     Initial version:  May, 1998  (Atsushi Murai <amurai@spec.co.jp>)
39
40     See HISTORY file for record of revisions.
41 */
42
43 /* Includes */
44 #ifdef _KERNEL
45 #include <sys/param.h>
46 #include <sys/systm.h>
47 #include <sys/kernel.h>
48 #include <sys/module.h>
49 #else
50 #include <errno.h>
51 #include <sys/types.h>
52 #include <stdio.h>
53 #endif
54
55 #include <netinet/in_systm.h>
56 #include <netinet/in.h>
57 #include <netinet/ip.h>
58 #include <netinet/udp.h>
59
60 #ifdef _KERNEL
61 #include <netinet/libalias/alias_local.h>
62 #include <netinet/libalias/alias_mod.h>
63 #else
64 #include "alias_local.h"
65 #include "alias_mod.h"
66 #endif
67
68 #define NETBIOS_NS_PORT_NUMBER 137
69 #define NETBIOS_DGM_PORT_NUMBER 138
70
71 static int
72 AliasHandleUdpNbt(struct libalias *, struct ip *, struct alias_link *,
73                   struct in_addr *, u_short);
74
75 static int
76 AliasHandleUdpNbtNS(struct libalias *, struct ip *, struct alias_link *,
77                     struct in_addr *, u_short *, struct in_addr *, u_short *);
78 static int
79 fingerprint1(struct libalias *la, struct ip *pip, struct alias_data *ah)
80 {
81
82         if (ah->dport == NULL || ah->sport == NULL || ah->lnk == NULL ||
83             ah->aaddr == NULL || ah->aport == NULL)
84                 return (-1);
85         if (ntohs(*ah->dport) == NETBIOS_DGM_PORT_NUMBER
86             || ntohs(*ah->sport) == NETBIOS_DGM_PORT_NUMBER)
87                 return (0);
88         return (-1);
89 }
90
91 static int
92 protohandler1(struct libalias *la, struct ip *pip, struct alias_data *ah)
93 {
94
95         AliasHandleUdpNbt(la, pip, ah->lnk, ah->aaddr, *ah->aport);
96         return (0);
97 }
98
99 static int
100 fingerprint2(struct libalias *la, struct ip *pip, struct alias_data *ah)
101 {
102
103         if (ah->dport == NULL || ah->sport == NULL || ah->lnk == NULL ||
104             ah->aaddr == NULL || ah->aport == NULL)
105                 return (-1);
106         if (ntohs(*ah->dport) == NETBIOS_NS_PORT_NUMBER
107             || ntohs(*ah->sport) == NETBIOS_NS_PORT_NUMBER)
108                 return (0);
109         return (-1);
110 }
111
112 static int
113 protohandler2in(struct libalias *la, struct ip *pip, struct alias_data *ah)
114 {
115
116         AliasHandleUdpNbtNS(la, pip, ah->lnk, ah->aaddr, ah->aport,
117                             ah->oaddr, ah->dport);
118         return (0);
119 }
120
121 static int
122 protohandler2out(struct libalias *la, struct ip *pip, struct alias_data *ah)
123 {
124
125         AliasHandleUdpNbtNS(la, pip, ah->lnk, &pip->ip_src, ah->sport,
126                             ah->aaddr, ah->aport);
127         return (0);
128 }
129
130 /* Kernel module definition. */
131 struct proto_handler handlers[] = {
132         {
133           .pri = 130,
134           .dir = IN|OUT,
135           .proto = UDP,
136           .fingerprint = &fingerprint1,
137           .protohandler = &protohandler1
138         },
139         {
140           .pri = 140,
141           .dir = IN,
142           .proto = UDP,
143           .fingerprint = &fingerprint2,
144           .protohandler = &protohandler2in
145         },
146         {
147           .pri = 140,
148           .dir = OUT,
149           .proto = UDP,
150           .fingerprint = &fingerprint2,
151           .protohandler = &protohandler2out
152         },
153         { EOH }
154 };
155
156 static int
157 mod_handler(module_t mod, int type, void *data)
158 {
159         int error;
160
161         switch (type) {
162         case MOD_LOAD:
163                 error = 0;
164                 LibAliasAttachHandlers(handlers);
165                 break;
166         case MOD_UNLOAD:
167                 error = 0;
168                 LibAliasDetachHandlers(handlers);
169                 break;
170         default:
171                 error = EINVAL;
172         }
173         return (error);
174 }
175
176 #ifdef  _KERNEL
177 static
178 #endif
179 moduledata_t alias_mod = {
180        "alias_nbt", mod_handler, NULL
181 };
182
183 #ifdef  _KERNEL
184 DECLARE_MODULE(alias_nbt, alias_mod, SI_SUB_DRIVERS, SI_ORDER_SECOND);
185 MODULE_VERSION(alias_nbt, 1);
186 MODULE_DEPEND(alias_nbt, libalias, 1, 1, 1);
187 #endif
188
189 typedef struct {
190         struct in_addr  oldaddr;
191         u_short         oldport;
192         struct in_addr  newaddr;
193         u_short         newport;
194         u_short        *uh_sum;
195 }               NBTArguments;
196
197 typedef struct {
198         unsigned char   type;
199         unsigned char   flags;
200         u_short         id;
201         struct in_addr  source_ip;
202         u_short         source_port;
203         u_short         len;
204         u_short         offset;
205 }               NbtDataHeader;
206
207 #define OpQuery         0
208 #define OpUnknown       4
209 #define OpRegist        5
210 #define OpRelease       6
211 #define OpWACK          7
212 #define OpRefresh       8
213 typedef struct {
214         u_short         nametrid;
215         u_short         dir:    1, opcode:4, nmflags:7, rcode:4;
216         u_short         qdcount;
217         u_short         ancount;
218         u_short         nscount;
219         u_short         arcount;
220 }               NbtNSHeader;
221
222 #define FMT_ERR         0x1
223 #define SRV_ERR         0x2
224 #define IMP_ERR         0x4
225 #define RFS_ERR         0x5
226 #define ACT_ERR         0x6
227 #define CFT_ERR         0x7
228
229
230 #ifdef LIBALIAS_DEBUG
231 static void
232 PrintRcode(u_char rcode)
233 {
234
235         switch (rcode) {
236                 case FMT_ERR:
237                 kprintf("\nFormat Error.");
238         case SRV_ERR:
239                 kprintf("\nSever failure.");
240         case IMP_ERR:
241                 kprintf("\nUnsupported request error.\n");
242         case RFS_ERR:
243                 kprintf("\nRefused error.\n");
244         case ACT_ERR:
245                 kprintf("\nActive error.\n");
246         case CFT_ERR:
247                 kprintf("\nName in conflict error.\n");
248         default:
249                 kprintf("\n?%c?=%0x\n", '?', rcode);
250
251         }
252 }
253
254 #endif
255
256
257 /* Handling Name field */
258 static u_char  *
259 AliasHandleName(u_char * p, char *pmax)
260 {
261
262         u_char *s;
263         u_char c;
264         int compress;
265
266         /* Following length field */
267
268         if (p == NULL || (char *)p >= pmax)
269                 return (NULL);
270
271         if (*p & 0xc0) {
272                 p = p + 2;
273                 if ((char *)p > pmax)
274                         return (NULL);
275                 return ((u_char *) p);
276         }
277         while ((*p & 0x3f) != 0x00) {
278                 s = p + 1;
279                 if (*p == 0x20)
280                         compress = 1;
281                 else
282                         compress = 0;
283
284                 /* Get next length field */
285                 p = (u_char *) (p + (*p & 0x3f) + 1);
286                 if ((char *)p > pmax) {
287                         p = NULL;
288                         break;
289                 }
290 #ifdef LIBALIAS_DEBUG
291                 kprintf(":");
292 #endif
293                 while (s < p) {
294                         if (compress == 1) {
295                                 c = (u_char) (((((*s & 0x0f) << 4) | (*(s + 1) & 0x0f)) - 0x11));
296 #ifdef LIBALIAS_DEBUG
297                                 if (isprint(c))
298                                         kprintf("%c", c);
299                                 else
300                                         kprintf("<0x%02x>", c);
301 #endif
302                                 s += 2;
303                         } else {
304 #ifdef LIBALIAS_DEBUG
305                                 kprintf("%c", *s);
306 #endif
307                                 s++;
308                         }
309                 }
310 #ifdef LIBALIAS_DEBUG
311                 kprintf(":");
312                 fflush(stdout);
313 #endif
314         }
315
316         /* Set up to out of Name field */
317         if (p == NULL || (char *)p >= pmax)
318                 p = NULL;
319         else
320                 p++;
321         return ((u_char *) p);
322 }
323
324 /*
325  * NetBios Datagram Handler (IP/UDP)
326  */
327 #define DGM_DIRECT_UNIQ         0x10
328 #define DGM_DIRECT_GROUP        0x11
329 #define DGM_BROADCAST           0x12
330 #define DGM_ERROR                       0x13
331 #define DGM_QUERY                       0x14
332 #define DGM_POSITIVE_RES        0x15
333 #define DGM_NEGATIVE_RES        0x16
334
335 static int
336 AliasHandleUdpNbt(
337     struct libalias *la,
338     struct ip *pip,             /* IP packet to examine/patch */
339     struct alias_link *lnk,
340     struct in_addr *alias_address,
341     u_short alias_port
342 )
343 {
344         struct udphdr *uh;
345         NbtDataHeader *ndh;
346         u_char *p = NULL;
347         char *pmax;
348
349         (void)la;
350         (void)lnk;
351
352         /* Calculate data length of UDP packet */
353         uh = (struct udphdr *)ip_next(pip);
354         pmax = (char *)uh + ntohs(uh->uh_ulen);
355
356         ndh = (NbtDataHeader *)udp_next(uh);
357         if ((char *)(ndh + 1) > pmax)
358                 return (-1);
359 #ifdef LIBALIAS_DEBUG
360         kprintf("\nType=%02x,", ndh->type);
361 #endif
362         switch (ndh->type) {
363         case DGM_DIRECT_UNIQ:
364         case DGM_DIRECT_GROUP:
365         case DGM_BROADCAST:
366                 p = (u_char *) ndh + 14;
367                 p = AliasHandleName(p, pmax);   /* Source Name */
368                 p = AliasHandleName(p, pmax);   /* Destination Name */
369                 break;
370         case DGM_ERROR:
371                 p = (u_char *) ndh + 11;
372                 break;
373         case DGM_QUERY:
374         case DGM_POSITIVE_RES:
375         case DGM_NEGATIVE_RES:
376                 p = (u_char *) ndh + 10;
377                 p = AliasHandleName(p, pmax);   /* Destination Name */
378                 break;
379         }
380         if (p == NULL || (char *)p > pmax)
381                 p = NULL;
382 #ifdef LIBALIAS_DEBUG
383         kprintf("%s:%d-->", inet_ntoa(ndh->source_ip), ntohs(ndh->source_port));
384 #endif
385         /* Doing an IP address and Port number Translation */
386         if (uh->uh_sum != 0) {
387                 int acc;
388                 u_short *sptr;
389
390                 acc = ndh->source_port;
391                 acc -= alias_port;
392                 sptr = (u_short *) & (ndh->source_ip);
393                 acc += *sptr++;
394                 acc += *sptr;
395                 sptr = (u_short *) alias_address;
396                 acc -= *sptr++;
397                 acc -= *sptr;
398                 ADJUST_CHECKSUM(acc, uh->uh_sum);
399         }
400         ndh->source_ip = *alias_address;
401         ndh->source_port = alias_port;
402 #ifdef LIBALIAS_DEBUG
403         kprintf("%s:%d\n", inet_ntoa(ndh->source_ip), ntohs(ndh->source_port));
404         fflush(stdout);
405 #endif
406         return ((p == NULL) ? -1 : 0);
407 }
408
409 /* Question Section */
410 #define QS_TYPE_NB              0x0020
411 #define QS_TYPE_NBSTAT  0x0021
412 #define QS_CLAS_IN              0x0001
413 typedef struct {
414         u_short         type;   /* The type of Request */
415         u_short         class;  /* The class of Request */
416 }               NBTNsQuestion;
417
418 static u_char  *
419 AliasHandleQuestion(
420     u_short count,
421     NBTNsQuestion * q,
422     char *pmax,
423     NBTArguments * nbtarg)
424 {
425
426         (void)nbtarg;
427
428         while (count != 0) {
429                 /* Name Filed */
430                 q = (NBTNsQuestion *) AliasHandleName((u_char *) q, pmax);
431
432                 if (q == NULL || (char *)(q + 1) > pmax) {
433                         q = NULL;
434                         break;
435                 }
436                 /* Type and Class filed */
437                 switch (ntohs(q->type)) {
438                 case QS_TYPE_NB:
439                 case QS_TYPE_NBSTAT:
440                         q = q + 1;
441                         break;
442                 default:
443 #ifdef LIBALIAS_DEBUG
444                         kprintf("\nUnknown Type on Question %0x\n", ntohs(q->type));
445 #endif
446                         break;
447                 }
448                 count--;
449         }
450
451         /* Set up to out of Question Section */
452         return ((u_char *) q);
453 }
454
455 /* Resource Record */
456 #define RR_TYPE_A               0x0001
457 #define RR_TYPE_NS              0x0002
458 #define RR_TYPE_NULL    0x000a
459 #define RR_TYPE_NB              0x0020
460 #define RR_TYPE_NBSTAT  0x0021
461 #define RR_CLAS_IN              0x0001
462 #define SizeOfNsResource        8
463 typedef struct {
464         u_short         type;
465         u_short         class;
466         unsigned int    ttl;
467         u_short         rdlen;
468 }               NBTNsResource;
469
470 #define SizeOfNsRNB                     6
471 typedef struct {
472         u_short         g:      1  , ont:2, resv:13;
473         struct in_addr  addr;
474 }               NBTNsRNB;
475
476 static u_char  *
477 AliasHandleResourceNB(
478     NBTNsResource * q,
479     char *pmax,
480     NBTArguments * nbtarg)
481 {
482         NBTNsRNB *nb;
483         u_short bcount;
484
485         if (q == NULL || (char *)(q + 1) > pmax)
486                 return (NULL);
487         /* Check out a length */
488         bcount = ntohs(q->rdlen);
489
490         /* Forward to Resource NB position */
491         nb = (NBTNsRNB *) ((u_char *) q + SizeOfNsResource);
492
493         /* Processing all in_addr array */
494 #ifdef LIBALIAS_DEBUG
495         kprintf("NB rec[%s", inet_ntoa(nbtarg->oldaddr));
496         kprintf("->%s, %dbytes] ", inet_ntoa(nbtarg->newaddr), bcount);
497 #endif
498         while (nb != NULL && bcount != 0) {
499                 if ((char *)(nb + 1) > pmax) {
500                         nb = NULL;
501                         break;
502                 }
503 #ifdef LIBALIAS_DEBUG
504                 kprintf("<%s>", inet_ntoa(nb->addr));
505 #endif
506                 if (!bcmp(&nbtarg->oldaddr, &nb->addr, sizeof(struct in_addr))) {
507                         if (*nbtarg->uh_sum != 0) {
508                                 int acc;
509                                 u_short *sptr;
510
511                                 sptr = (u_short *) & (nb->addr);
512                                 acc = *sptr++;
513                                 acc += *sptr;
514                                 sptr = (u_short *) & (nbtarg->newaddr);
515                                 acc -= *sptr++;
516                                 acc -= *sptr;
517                                 ADJUST_CHECKSUM(acc, *nbtarg->uh_sum);
518                         }
519                         nb->addr = nbtarg->newaddr;
520 #ifdef LIBALIAS_DEBUG
521                         kprintf("O");
522 #endif
523                 }
524 #ifdef LIBALIAS_DEBUG
525                 else {
526                         kprintf(".");
527                 }
528 #endif
529                 nb = (NBTNsRNB *) ((u_char *) nb + SizeOfNsRNB);
530                 bcount -= SizeOfNsRNB;
531         }
532         if (nb == NULL || (char *)(nb + 1) > pmax) {
533                 nb = NULL;
534         }
535         return ((u_char *) nb);
536 }
537
538 #define SizeOfResourceA         6
539 typedef struct {
540         struct in_addr  addr;
541 }               NBTNsResourceA;
542
543 static u_char  *
544 AliasHandleResourceA(
545     NBTNsResource * q,
546     char *pmax,
547     NBTArguments * nbtarg)
548 {
549         NBTNsResourceA *a;
550         u_short bcount;
551
552         if (q == NULL || (char *)(q + 1) > pmax)
553                 return (NULL);
554
555         /* Forward to Resource A position */
556         a = (NBTNsResourceA *) ((u_char *) q + sizeof(NBTNsResource));
557
558         /* Check out of length */
559         bcount = ntohs(q->rdlen);
560
561         /* Processing all in_addr array */
562 #ifdef LIBALIAS_DEBUG
563         kprintf("Arec [%s", inet_ntoa(nbtarg->oldaddr));
564         kprintf("->%s]", inet_ntoa(nbtarg->newaddr));
565 #endif
566         while (bcount != 0) {
567                 if (a == NULL || (char *)(a + 1) > pmax)
568                         return (NULL);
569 #ifdef LIBALIAS_DEBUG
570                 kprintf("..%s", inet_ntoa(a->addr));
571 #endif
572                 if (!bcmp(&nbtarg->oldaddr, &a->addr, sizeof(struct in_addr))) {
573                         if (*nbtarg->uh_sum != 0) {
574                                 int acc;
575                                 u_short *sptr;
576
577                                 sptr = (u_short *) & (a->addr); /* Old */
578                                 acc = *sptr++;
579                                 acc += *sptr;
580                                 sptr = (u_short *) & nbtarg->newaddr;   /* New */
581                                 acc -= *sptr++;
582                                 acc -= *sptr;
583                                 ADJUST_CHECKSUM(acc, *nbtarg->uh_sum);
584                         }
585                         a->addr = nbtarg->newaddr;
586                 }
587                 a++;            /* XXXX */
588                 bcount -= SizeOfResourceA;
589         }
590         if (a == NULL || (char *)(a + 1) > pmax)
591                 a = NULL;
592         return ((u_char *) a);
593 }
594
595 typedef struct {
596         u_short         opcode:4, flags:8, resv:4;
597 }               NBTNsResourceNULL;
598
599 static u_char  *
600 AliasHandleResourceNULL(
601     NBTNsResource * q,
602     char *pmax,
603     NBTArguments * nbtarg)
604 {
605         NBTNsResourceNULL *n;
606         u_short bcount;
607
608         (void)nbtarg;
609
610         if (q == NULL || (char *)(q + 1) > pmax)
611                 return (NULL);
612
613         /* Forward to Resource NULL position */
614         n = (NBTNsResourceNULL *) ((u_char *) q + sizeof(NBTNsResource));
615
616         /* Check out of length */
617         bcount = ntohs(q->rdlen);
618
619         /* Processing all in_addr array */
620         while (bcount != 0) {
621                 if ((char *)(n + 1) > pmax) {
622                         n = NULL;
623                         break;
624                 }
625                 n++;
626                 bcount -= sizeof(NBTNsResourceNULL);
627         }
628         if ((char *)(n + 1) > pmax)
629                 n = NULL;
630
631         return ((u_char *) n);
632 }
633
634 static u_char  *
635 AliasHandleResourceNS(
636     NBTNsResource * q,
637     char *pmax,
638     NBTArguments * nbtarg)
639 {
640         NBTNsResourceNULL *n;
641         u_short bcount;
642
643         (void)nbtarg;
644
645         if (q == NULL || (char *)(q + 1) > pmax)
646                 return (NULL);
647
648         /* Forward to Resource NULL position */
649         n = (NBTNsResourceNULL *) ((u_char *) q + sizeof(NBTNsResource));
650
651         /* Check out of length */
652         bcount = ntohs(q->rdlen);
653
654         /* Resource Record Name Filed */
655         q = (NBTNsResource *) AliasHandleName((u_char *) n, pmax);      /* XXX */
656
657         if (q == NULL || (char *)((u_char *) n + bcount) > pmax)
658                 return (NULL);
659         else
660                 return ((u_char *) n + bcount);
661 }
662
663 typedef struct {
664         u_short         numnames;
665 }               NBTNsResourceNBSTAT;
666
667 static u_char  *
668 AliasHandleResourceNBSTAT(
669     NBTNsResource * q,
670     char *pmax,
671     NBTArguments * nbtarg)
672 {
673         NBTNsResourceNBSTAT *n;
674         u_short bcount;
675
676         (void)nbtarg;
677
678         if (q == NULL || (char *)(q + 1) > pmax)
679                 return (NULL);
680
681         /* Forward to Resource NBSTAT position */
682         n = (NBTNsResourceNBSTAT *) ((u_char *) q + sizeof(NBTNsResource));
683
684         /* Check out of length */
685         bcount = ntohs(q->rdlen);
686
687         if (q == NULL || (char *)((u_char *) n + bcount) > pmax)
688                 return (NULL);
689         else
690                 return ((u_char *) n + bcount);
691 }
692
693 static u_char  *
694 AliasHandleResource(
695     u_short count,
696     NBTNsResource * q,
697     char *pmax,
698     NBTArguments
699     * nbtarg)
700 {
701         while (count != 0) {
702                 /* Resource Record Name Filed */
703                 q = (NBTNsResource *) AliasHandleName((u_char *) q, pmax);
704
705                 if (q == NULL || (char *)(q + 1) > pmax)
706                         break;
707 #ifdef LIBALIAS_DEBUG
708                 kprintf("type=%02x, count=%d\n", ntohs(q->type), count);
709 #endif
710
711                 /* Type and Class filed */
712                 switch (ntohs(q->type)) {
713                 case RR_TYPE_NB:
714                         q = (NBTNsResource *) AliasHandleResourceNB(
715                             q,
716                             pmax,
717                             nbtarg
718                             );
719                         break;
720                 case RR_TYPE_A:
721                         q = (NBTNsResource *) AliasHandleResourceA(
722                             q,
723                             pmax,
724                             nbtarg
725                             );
726                         break;
727                 case RR_TYPE_NS:
728                         q = (NBTNsResource *) AliasHandleResourceNS(
729                             q,
730                             pmax,
731                             nbtarg
732                             );
733                         break;
734                 case RR_TYPE_NULL:
735                         q = (NBTNsResource *) AliasHandleResourceNULL(
736                             q,
737                             pmax,
738                             nbtarg
739                             );
740                         break;
741                 case RR_TYPE_NBSTAT:
742                         q = (NBTNsResource *) AliasHandleResourceNBSTAT(
743                             q,
744                             pmax,
745                             nbtarg
746                             );
747                         break;
748                 default:
749 #ifdef LIBALIAS_DEBUG
750                         kprintf(
751                             "\nUnknown Type of Resource %0x\n",
752                             ntohs(q->type)
753                             );
754                         fflush(stdout);
755 #endif
756                         break;
757                 }
758                 count--;
759         }
760         return ((u_char *) q);
761 }
762
763 static int
764 AliasHandleUdpNbtNS(
765     struct libalias *la,
766     struct ip *pip,             /* IP packet to examine/patch */
767     struct alias_link *lnk,
768     struct in_addr *alias_address,
769     u_short * alias_port,
770     struct in_addr *original_address,
771     u_short * original_port)
772 {
773         struct udphdr *uh;
774         NbtNSHeader *nsh;
775         u_char *p;
776         char *pmax;
777         NBTArguments nbtarg;
778
779         (void)la;
780         (void)lnk;
781
782         /* Set up Common Parameter */
783         nbtarg.oldaddr = *alias_address;
784         nbtarg.oldport = *alias_port;
785         nbtarg.newaddr = *original_address;
786         nbtarg.newport = *original_port;
787
788         /* Calculate data length of UDP packet */
789         uh = (struct udphdr *)ip_next(pip);
790         nbtarg.uh_sum = &(uh->uh_sum);
791         nsh = (NbtNSHeader *)udp_next(uh);
792         p = (u_char *) (nsh + 1);
793         pmax = (char *)uh + ntohs(uh->uh_ulen);
794
795         if ((char *)(nsh + 1) > pmax)
796                 return (-1);
797
798 #ifdef LIBALIAS_DEBUG
799         kprintf(" [%s] ID=%02x, op=%01x, flag=%02x, rcode=%01x, qd=%04x"
800             ", an=%04x, ns=%04x, ar=%04x, [%d]-->",
801             nsh->dir ? "Response" : "Request",
802             nsh->nametrid,
803             nsh->opcode,
804             nsh->nmflags,
805             nsh->rcode,
806             ntohs(nsh->qdcount),
807             ntohs(nsh->ancount),
808             ntohs(nsh->nscount),
809             ntohs(nsh->arcount),
810             (u_char *) p - (u_char *) nsh
811             );
812 #endif
813
814         /* Question Entries */
815         if (ntohs(nsh->qdcount) != 0) {
816                 p = AliasHandleQuestion(
817                     ntohs(nsh->qdcount),
818                     (NBTNsQuestion *) p,
819                     pmax,
820                     &nbtarg
821                     );
822         }
823         /* Answer Resource Records */
824         if (ntohs(nsh->ancount) != 0) {
825                 p = AliasHandleResource(
826                     ntohs(nsh->ancount),
827                     (NBTNsResource *) p,
828                     pmax,
829                     &nbtarg
830                     );
831         }
832         /* Authority Resource Recodrs */
833         if (ntohs(nsh->nscount) != 0) {
834                 p = AliasHandleResource(
835                     ntohs(nsh->nscount),
836                     (NBTNsResource *) p,
837                     pmax,
838                     &nbtarg
839                     );
840         }
841         /* Additional Resource Recodrs */
842         if (ntohs(nsh->arcount) != 0) {
843                 p = AliasHandleResource(
844                     ntohs(nsh->arcount),
845                     (NBTNsResource *) p,
846                     pmax,
847                     &nbtarg
848                     );
849         }
850 #ifdef LIBALIAS_DEBUG
851         PrintRcode(nsh->rcode);
852 #endif
853         return ((p == NULL) ? -1 : 0);
854 }