Return to sock.c CVS log

Up to [Early Linux] / linux / net / tcp

Annotation of linux/net/tcp/sock.c, revision 1.1

1.1     ! root        1: /* sock.c */
        !             2: /*
        !             3:     Copyright (C) 1992  Ross Biro
        !             4: 
        !             5:     This program is free software; you can redistribute it and/or modify
        !             6:     it under the terms of the GNU General Public License as published by
        !             7:     the Free Software Foundation; either version 2, or (at your option)
        !             8:     any later version.
        !             9: 
        !            10:     This program is distributed in the hope that it will be useful,
        !            11:     but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            12:     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            13:     GNU General Public License for more details.
        !            14: 
        !            15:     You should have received a copy of the GNU General Public License
        !            16:     along with this program; if not, write to the Free Software
        !            17:     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
        !            18: 
        !            19:     The Author may be reached as [email protected] or
        !            20:     C/O Department of Mathematics; Stanford University; Stanford, CA 94305
        !            21: */
        !            22: #include <linux/errno.h>
        !            23: #include <linux/types.h>
        !            24: #include <linux/socket.h>
        !            25: #include <netinet/in.h>
        !            26: #include <linux/kernel.h>
        !            27: #include <linux/sched.h>
        !            28: #include <linux/timer.h>
        !            29: #include <linux/sock_ioctl.h>
        !            30: #include <asm/memory.h>
        !            31: #include "../kern_sock.h"
        !            32: #include "timer.h"
        !            33: #include "ip.h"
        !            34: #include "tcp.h"
        !            35: #include "udp.h"
        !            36: #include "sock.h"
        !            37: #include <asm/segment.h>
        !            38: #include <asm/system.h>
        !            39: #include <linux/fcntl.h>
        !            40: 
        !            41: #ifdef MEM_DEBUG
        !            42: #define MPRINTK printk
        !            43: #else
        !            44: #define MPRINTK dummy_routine
        !            45: #endif
        !            46: 
        !            47: #define min(a,b) ((a)<(b)?(a):(b))
        !            48: #define swap(a,b) {unsigned long c; c=a; a=b; b=c;}
        !            49: 
        !            50: extern struct proto tcp_prot;
        !            51: extern struct proto udp_prot;
        !            52: extern struct proto raw_prot;
        !            53: extern struct proto packet_prot;
        !            54: 
        !            55: static int ip_proto_init(void);
        !            56: static int ip_proto_create(struct socket *sock, int protocol);
        !            57: static int ip_proto_dup(struct socket *newsock, struct socket *oldsock);
        !            58: static int ip_proto_release(struct socket *sock, struct socket *peer);
        !            59: static int ip_proto_bind(struct socket *sock, struct sockaddr *umyaddr,
        !            60:                           int sockaddr_len);
        !            61: static int ip_proto_connect(struct socket *sock, struct sockaddr *uservaddr,
        !            62:                              int sockaddr_len, int flags);
        !            63: static int ip_proto_socketpair(struct socket *sock1, struct socket *sock2);
        !            64: static int ip_proto_accept(struct socket *sock, struct socket *newsock, int flags);
        !            65: static int ip_proto_getname(struct socket *sock, struct sockaddr *usockaddr,
        !            66:                              int *usockaddr_len, int peer);
        !            67: static int ip_proto_read(struct socket *sock, char *ubuf, int size,
        !            68:                           int nonblock);
        !            69: static int ip_proto_write(struct socket *sock, char *ubuf, int size,
        !            70:                            int nonblock);
        !            71: static int ip_proto_select(struct socket *sock, int which, select_table *wait);
        !            72: static int ip_proto_ioctl(struct socket *sock, unsigned int cmd,
        !            73:                            unsigned long arg);
        !            74: static int ip_proto_listen(struct socket *sock, int backlog);
        !            75: 
        !            76: static int ip_proto_send (struct socket *sock, void *buff, int len,
        !            77:                          int nonblock, unsigned flags);
        !            78: static int ip_proto_recv (struct socket *sock, void *buff, int len,
        !            79:                          int nonblock, unsigned flags);
        !            80: static int ip_proto_sendto (struct socket *sock, void *buff, int len,
        !            81:                            int nonblock, unsigned flags,
        !            82:                            struct sockaddr *addr, int addr_len);
        !            83: static int ip_proto_recvfrom (struct socket *sock, void *buff, int len,
        !            84:                              int nonblock, unsigned flags,
        !            85:                              struct sockaddr *addr, int *addr_len);
        !            86: 
        !            87: static int ip_proto_shutdown (struct socket *sock, int how);
        !            88: 
        !            89: 
        !            90: static int ip_proto_setsockopt (struct socket *sock, int level, int optname,
        !            91:                                char *optval, int optlen);
        !            92: static int ip_proto_getsockopt (struct socket *sock, int level, int optname,
        !            93:                                char *optval, int *optlen);
        !            94: static int ip_proto_fcntl (struct socket *sock, unsigned int cmd,
        !            95:                           unsigned long arg);
        !            96: 
        !            97: 
        !            98: struct proto_ops inet_proto_ops = 
        !            99: {
        !           100:   ip_proto_init,
        !           101:   ip_proto_create,
        !           102:   ip_proto_dup,
        !           103:   ip_proto_release,
        !           104:   ip_proto_bind,
        !           105:   ip_proto_connect,
        !           106:   ip_proto_socketpair,
        !           107:   ip_proto_accept,
        !           108:   ip_proto_getname, 
        !           109:   ip_proto_read,
        !           110:   ip_proto_write,
        !           111:   ip_proto_select,
        !           112:   ip_proto_ioctl,
        !           113:   ip_proto_listen,
        !           114:   ip_proto_send,
        !           115:   ip_proto_recv,
        !           116:   ip_proto_sendto,
        !           117:   ip_proto_recvfrom,
        !           118:   ip_proto_shutdown,
        !           119:   ip_proto_setsockopt,
        !           120:   ip_proto_getsockopt,
        !           121:   ip_proto_fcntl
        !           122: };
        !           123: 
        !           124: void
        !           125: print_sk (volatile struct sock *sk)
        !           126: {
        !           127:   PRINTK ("  wmem_alloc = %d\n", sk->wmem_alloc);
        !           128:   PRINTK ("  rmem_alloc = %d\n", sk->rmem_alloc);
        !           129:   PRINTK ("  send_head = %X\n", sk->send_head);
        !           130:   PRINTK ("  state = %d\n",sk->state);
        !           131:   PRINTK ("  wback = %X, rqueue = %X\n", sk->wback, sk->rqueue);
        !           132:   PRINTK ("  wfront = %X\n", sk->wfront);
        !           133:   PRINTK ("  daddr = %X, saddr = %X\n", sk->daddr,sk->saddr);
        !           134:   PRINTK ("  num = %d", sk->num);
        !           135:   PRINTK (" next = %X\n", sk->next);
        !           136:   PRINTK ("  send_seq = %d, acked_seq = %d, copied_seq = %d\n",
        !           137:          sk->send_seq, sk->acked_seq, sk->copied_seq);
        !           138:   PRINTK ("  rcv_ack_seq = %d, window_seq = %d, fin_seq = %d\n",
        !           139:          sk->rcv_ack_seq, sk->window_seq, sk->fin_seq);
        !           140:   PRINTK ("  prot = %X\n", sk->prot);
        !           141:   PRINTK ("  pair = %X, back_log = %X\n", sk->pair,sk->back_log);
        !           142:   PRINTK ("  inuse = %d , blog = %d\n", sk->inuse, sk->blog);
        !           143:   PRINTK ("  dead = %d delay_acks=%d\n", sk->dead, sk->delay_acks);
        !           144:   PRINTK ("  retransmits = %d, timeout = %d\n", sk->retransmits, sk->timeout);
        !           145:   PRINTK ("  cong_window = %d, packets_out = %d\n", sk->cong_window,
        !           146:          sk->packets_out);
        !           147: }
        !           148: 
        !           149: void
        !           150: print_skb(struct sk_buff *skb)
        !           151: {
        !           152:   PRINTK ("  prev = %X, next = %X\n", skb->prev, skb->next);
        !           153:   PRINTK ("  sk = %X link3 = %X\n", skb->sk, skb->link3);
        !           154:   PRINTK ("  mem_addr = %X, mem_len = %d\n", skb->mem_addr, skb->mem_len);
        !           155:   PRINTK ("  used = %d free = %d\n", skb->used,skb->free);
        !           156: }
        !           157: 
        !           158: /* just used to reference some pointers to keep gcc from over optimizing
        !           159:    my code so that it doesn't work. */
        !           160: void dummy_routine(void *dummy, ...)
        !           161: {
        !           162:    return;
        !           163: }
        !           164: 
        !           165: void
        !           166: lock_skb (struct sk_buff *skb)
        !           167: {
        !           168:    if (skb->lock)
        !           169:      {
        !           170:        printk ("*** bug more than one lock on sk_buff. \n");
        !           171:      }
        !           172:    skb->lock = 1;
        !           173: }
        !           174: 
        !           175: 
        !           176: void
        !           177: free_skb (struct sk_buff *skb, int rw)
        !           178: {
        !           179:    if (skb->lock)
        !           180:      {
        !           181:        skb->free = 1;
        !           182:        return;
        !           183:      }
        !           184:    if (skb->sk)
        !           185:      {
        !           186:        if (rw)
        !           187:          {
        !           188:             skb->sk->prot->rfree (skb->sk, skb->mem_addr, skb->mem_len);
        !           189:          }
        !           190:        else
        !           191:          {
        !           192:             skb->sk->prot->wfree (skb->sk, skb->mem_addr, skb->mem_len);
        !           193:          }
        !           194:      }
        !           195:    else
        !           196:      {
        !           197:        free_s (skb->mem_addr, skb->mem_len);
        !           198:      }
        !           199: }
        !           200: 
        !           201: void
        !           202: unlock_skb (struct sk_buff *skb, int rw)
        !           203: {
        !           204:    if (skb->lock != 1)
        !           205:      {
        !           206:        printk ("*** bug unlocking non-locked sk_buff. \n");
        !           207:      }
        !           208:    skb->lock = 0;
        !           209:    if (skb->free)
        !           210:      free_skb (skb, rw);
        !           211: }
        !           212: 
        !           213: static  int
        !           214: sk_inuse( struct proto *prot, int num)
        !           215: {
        !           216:   volatile struct sock *sk;
        !           217:   for (sk = prot->sock_array[num & (SOCK_ARRAY_SIZE -1 )];
        !           218:        sk != NULL; sk=sk->next)
        !           219:     {
        !           220:       if (sk->dummy_th.source == num) return (1);
        !           221:     }
        !           222:   return (0);
        !           223: }
        !           224: 
        !           225: unsigned short
        !           226: get_new_socknum(struct proto *prot, unsigned short base)
        !           227: {
        !           228:   static int start=0;
        !           229:   /* used to cycle through the port numbers so the chances of
        !           230:      a confused connection drop. */
        !           231: 
        !           232:   int i,j;
        !           233:   int best=0;
        !           234:   int size=32767; /* a big num. */
        !           235:   volatile struct sock *sk;
        !           236:   start++;
        !           237:   if (base == 0) base = PROT_SOCK+1+(start % 1024);
        !           238:   if (base <= PROT_SOCK)
        !           239:     {
        !           240:       base += PROT_SOCK+(start % 1024);
        !           241:     }
        !           242: 
        !           243:   /* now look through the entire array and try to find an empty
        !           244:      ptr. */
        !           245:   for (i = 0; i < SOCK_ARRAY_SIZE; i++)
        !           246:     {
        !           247:       j = 0;
        !           248:       sk = prot->sock_array[(i+base+1) & (SOCK_ARRAY_SIZE -1)];
        !           249:       while (sk != NULL)
        !           250:        {
        !           251:          sk = sk->next;
        !           252:          j++;
        !           253:        }
        !           254:       if (j == 0) return (i+base+1);
        !           255:       if (j < size) 
        !           256:        {
        !           257:          best = i;
        !           258:          size = j;
        !           259:        }
        !           260:     }
        !           261:   /* now make sure the one we want is not in use. */
        !           262:   while (sk_inuse (prot, base +best+1))
        !           263:     {
        !           264:       best += SOCK_ARRAY_SIZE;
        !           265:     }
        !           266:   return (best+base+1);
        !           267:   
        !           268: }
        !           269: 
        !           270: void
        !           271: put_sock(unsigned short num, volatile struct sock *sk)
        !           272: {
        !           273:    volatile struct sock *sk1;
        !           274:    volatile struct sock *sk2;
        !           275:    int mask;
        !           276: 
        !           277:    PRINTK ("put_sock (num = %d, sk = %X\n", num, sk);
        !           278:    sk->num = num;
        !           279:    sk->next = NULL;
        !           280:    num = num & (SOCK_ARRAY_SIZE -1);
        !           281: 
        !           282:    /* we can't have an interupt renter here. */
        !           283:    cli();
        !           284:    if (sk->prot->sock_array[num] == NULL)
        !           285:      {
        !           286:        sk->prot->sock_array[num] = sk;
        !           287:        sti();
        !           288:        return;
        !           289:      }
        !           290:    sti();
        !           291:    for (mask = 0xff000000; mask != 0xffffffff; mask = (mask >> 8) | mask)
        !           292:      {
        !           293:        if (mask & sk->saddr)
        !           294:          {
        !           295:             mask = mask << 8;
        !           296:             break;
        !           297:          }
        !           298:      }
        !           299: 
        !           300:    PRINTK ("mask = %X\n", mask);
        !           301: 
        !           302:    cli();
        !           303:    sk1 = sk->prot->sock_array[num];
        !           304:    for (sk2 = sk1; sk2 != NULL; sk2=sk2->next)
        !           305:      {
        !           306:        if (!(sk2->saddr & mask))
        !           307:          {
        !           308:             if (sk2 == sk1)
        !           309:               {
        !           310:                  sk->next = sk->prot->sock_array[num];
        !           311:                  sk->prot->sock_array[num] = sk;
        !           312:                  sti();
        !           313:                  return;
        !           314:               }
        !           315:             sk->next = sk2;
        !           316:             sk1->next= sk;
        !           317:             sti();
        !           318:             return;
        !           319:          }
        !           320:        sk1 = sk2;
        !           321:      }
        !           322:    /* goes at the end. */
        !           323:    sk->next = NULL;
        !           324:    sk1->next = sk;
        !           325:    sti();
        !           326: }
        !           327: 
        !           328: 
        !           329: static void
        !           330: remove_sock(volatile struct sock *sk1)
        !           331: {
        !           332:   volatile struct sock *sk2;
        !           333:   PRINTK ("remove_sock(sk1=%X)\n",sk1);
        !           334: 
        !           335:   /* we can't have this changing out from under us. */
        !           336:   cli();
        !           337:   sk2=sk1->prot->sock_array[sk1->num & (SOCK_ARRAY_SIZE -1)];
        !           338:   if (sk2 == sk1)
        !           339:     {
        !           340:        sk1->prot->sock_array[sk1->num & (SOCK_ARRAY_SIZE -1)] = sk1->next;
        !           341:        sti();
        !           342:        return;
        !           343:     }
        !           344:   while (sk2->next != sk1)
        !           345:     {
        !           346:       if (sk2 == NULL)
        !           347:        {
        !           348:          sti();
        !           349:          PRINTK ("remove_sock: sock  not found.\n");
        !           350:          return;
        !           351:        }
        !           352:       sk2=sk2->next;
        !           353:     }
        !           354:   sk2->next = sk1->next;
        !           355:   sti();
        !           356: }
        !           357: 
        !           358: void
        !           359: destroy_sock(volatile struct sock *sk)
        !           360: {
        !           361: 
        !           362:   struct sk_buff *skb;
        !           363:   PRINTK ("destroying socket %X\n",sk);
        !           364:   /* just to be safe. */
        !           365:   sk->inuse = 1;
        !           366: 
        !           367:   remove_sock (sk);
        !           368:   /* now we can no longer get new packets. */
        !           369: 
        !           370:   delete_timer((struct timer *)&sk->time_wait);
        !           371: 
        !           372:   /* cleanup up the write buffer. */
        !           373:   for (skb = sk->wfront; skb != NULL; )
        !           374:     {
        !           375:       struct sk_buff *skb2;
        !           376:       skb2=skb->next;
        !           377:       free_skb(skb, FREE_WRITE);
        !           378:       skb=skb2;
        !           379:     }
        !           380: 
        !           381:   sk->wfront = NULL;
        !           382: 
        !           383:   if (sk->rqueue != NULL)
        !           384:     {
        !           385:        skb = sk->rqueue;
        !           386:        do {
        !           387:          struct sk_buff *skb2;
        !           388:          skb2=skb->next;
        !           389:          /* this will take care of closing sockets that were
        !           390:             listening and didn't accept everything. */
        !           391: 
        !           392:          if (skb->sk != NULL && skb->sk != sk)
        !           393:            {
        !           394:               skb->sk->dead = 1;
        !           395:               skb->sk->prot->close (skb->sk, 0);
        !           396:            }
        !           397:          free_skb(skb, FREE_READ);
        !           398:          skb=skb2;
        !           399:        } while (skb != sk->rqueue);
        !           400:     }
        !           401: 
        !           402:   sk->rqueue = NULL;
        !           403: 
        !           404:   /* now we need to clean up the send head. */
        !           405:   for (skb = sk->send_head; skb != NULL; )
        !           406:     {
        !           407:       struct sk_buff *skb2;
        !           408:       /* we need to remove skb from the transmit queue. */
        !           409:       cli();
        !           410:       /* see if it's in a transmit queue. */
        !           411:       if (skb->next != NULL)
        !           412:        {
        !           413:           if (skb->next != skb)
        !           414:             {
        !           415:                skb->next->prev = skb->prev;
        !           416:                skb->prev->next = skb->next;
        !           417:             }
        !           418:           else
        !           419:             {
        !           420:                int i;
        !           421:                for (i = 0; i < DEV_NUMBUFFS; i++)
        !           422:                  {
        !           423:                     if (skb->dev && skb->dev->buffs[i] == skb)
        !           424:                       {
        !           425:                          skb->dev->buffs[i]= NULL;
        !           426:                          break;
        !           427:                       }
        !           428:                  }
        !           429:             }
        !           430:        }
        !           431:       sti();
        !           432:       skb2=skb->link3;
        !           433:       free_skb(skb, FREE_WRITE);
        !           434:       skb=skb2;
        !           435:     }
        !           436: 
        !           437:   sk->send_head = NULL;
        !           438: 
        !           439:   /* and now the backlog. */
        !           440: 
        !           441:   if (sk->back_log != NULL)
        !           442:     {
        !           443:        /* this should never happen. */
        !           444:        printk ("cleaning back_log. \n");
        !           445:        cli();
        !           446:        skb = sk->back_log;
        !           447:        do {
        !           448:          struct sk_buff *skb2;
        !           449:          skb2=skb->next;
        !           450:          free_skb(skb, FREE_READ);
        !           451:          skb=skb2;
        !           452:        } while (skb != sk->back_log);
        !           453:        sti();
        !           454:     }
        !           455: 
        !           456:   sk->back_log = NULL;
        !           457: 
        !           458:   /* now if everything is gone we can free the socket structure, 
        !           459:      otherwise we need to keep it around until everything is gone. */
        !           460:   if (sk->rmem_alloc == 0 && sk->wmem_alloc == 0)
        !           461:     {
        !           462:        free_s ((void *)sk,sizeof (*sk));
        !           463:     }
        !           464:   else
        !           465:     {
        !           466:        /* this should never happen. */
        !           467:        /* actually it can if an ack has just been sent. */
        !           468:        PRINTK ("possible memory leak in socket = %X\n", sk);
        !           469:        print_sk (sk);
        !           470:        sk->destroy = 1;
        !           471:        sk->ack_backlog = 0;
        !           472:        sk->inuse = 0;
        !           473:        sk->time_wait.len = SOCK_DESTROY_TIME;
        !           474:        sk->timeout = TIME_DESTROY;
        !           475:        reset_timer ((struct timer *)&sk->time_wait);
        !           476:     }
        !           477:   
        !           478: }
        !           479: 
        !           480: 
        !           481: static int
        !           482: ip_proto_fcntl (struct socket *sock, unsigned int cmd, unsigned long arg)
        !           483: {
        !           484:    volatile struct sock *sk;
        !           485:    sk=sock->data;
        !           486:    if (sk == NULL)
        !           487:      {
        !           488:        printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !           489:        return (0);
        !           490:      }
        !           491:    switch (cmd)
        !           492:      {
        !           493:        case F_SETOWN:
        !           494:        sk->proc = arg;
        !           495:        return (0);
        !           496: 
        !           497:        case F_GETOWN:
        !           498:        return (sk->proc);
        !           499: 
        !           500:        default:
        !           501:        return (-EINVAL);
        !           502:      }
        !           503: }
        !           504: 
        !           505: static int
        !           506: ip_proto_setsockopt(struct socket *sock, int level, int optname,
        !           507:                    char *optval, int optlen)
        !           508: {
        !           509:     volatile struct sock *sk;
        !           510:     int val;
        !           511:     /* This should really pass things on to the other levels. */
        !           512:     if (level != SOL_SOCKET) return (-EOPNOTSUPP);
        !           513:     sk = sock->data;
        !           514:    if (sk == NULL)
        !           515:      {
        !           516:        printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !           517:        return (0);
        !           518:      }
        !           519:     verify_area (optval, sizeof (int));
        !           520:     val = get_fs_long ((unsigned long *)optval);
        !           521:     switch (optname)
        !           522:       {
        !           523:        case SO_TYPE:
        !           524:        case SO_ERROR:
        !           525:        default:
        !           526:          return (-ENOPROTOOPT);
        !           527: 
        !           528:        case SO_DEBUG: /* not implemented. */
        !           529:        case SO_DONTROUTE:
        !           530:        case SO_BROADCAST:
        !           531:        case SO_SNDBUF:
        !           532:        case SO_RCVBUF:
        !           533:          return (0);
        !           534: 
        !           535:        case SO_REUSEADDR:
        !           536:          if (val)
        !           537:            sk->reuse = 1;
        !           538:          else 
        !           539:            sk->reuse = 1;
        !           540:          return (0);
        !           541: 
        !           542:        case SO_KEEPALIVE:
        !           543:          if (val)
        !           544:            sk->keepopen = 1;
        !           545:          else
        !           546:            sk->keepopen = 0;
        !           547:          return (0);
        !           548: 
        !           549:         case SO_OOBINLINE:
        !           550:          if (val)
        !           551:            sk->urginline = 1;
        !           552:          else
        !           553:            sk->urginline = 0;
        !           554:          return (0);
        !           555: 
        !           556:         case SO_NO_CHECK:
        !           557:          if (val)
        !           558:            sk->no_check = 1;
        !           559:          else
        !           560:            sk->no_check = 0;
        !           561:          return (0);
        !           562: 
        !           563:         case SO_PRIORITY:
        !           564:          if (val >= 0 && val < DEV_NUMBUFFS)
        !           565:            {
        !           566:               sk->priority = val;
        !           567:            }
        !           568:          else
        !           569:            {
        !           570:               return (-EINVAL);
        !           571:            }
        !           572:          return (0);
        !           573: 
        !           574:       }
        !           575: }
        !           576: 
        !           577: static int
        !           578: ip_proto_getsockopt(struct socket *sock, int level, int optname,
        !           579:                    char *optval, int *optlen)
        !           580: {
        !           581:     volatile struct sock *sk;
        !           582:     int val;
        !           583:     /* This should really pass things on to the other levels. */
        !           584:     if (level != SOL_SOCKET) return (-EOPNOTSUPP);
        !           585:     sk = sock->data;
        !           586:    if (sk == NULL)
        !           587:      {
        !           588:        printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !           589:        return (0);
        !           590:      }
        !           591:     switch (optname)
        !           592:       {
        !           593:        default:
        !           594:          return (-ENOPROTOOPT);
        !           595: 
        !           596:        case SO_DEBUG: /* not implemented. */
        !           597:        case SO_DONTROUTE:
        !           598:        case SO_BROADCAST:
        !           599:        case SO_SNDBUF:
        !           600:        case SO_RCVBUF:
        !           601:          val = 0;
        !           602:          break;
        !           603: 
        !           604:        case SO_REUSEADDR:
        !           605:          val = sk->reuse;
        !           606:          break;
        !           607: 
        !           608:        case SO_KEEPALIVE:
        !           609:          val = sk->keepopen;
        !           610:          break;
        !           611: 
        !           612:        case SO_TYPE:
        !           613:          if (sk->prot == &tcp_prot)
        !           614:            val = SOCK_STREAM;
        !           615:          else
        !           616:            val = SOCK_DGRAM;
        !           617:          break;
        !           618: 
        !           619:        case SO_ERROR:
        !           620:          val = sk->err;
        !           621:          sk->err = 0;
        !           622:          break;
        !           623: 
        !           624:         case SO_OOBINLINE:
        !           625:          val = sk->urginline;
        !           626:          break;
        !           627: 
        !           628:         case SO_NO_CHECK:
        !           629:          val = sk->no_check;
        !           630:          break;
        !           631: 
        !           632:         case SO_PRIORITY:
        !           633:          val = sk->priority;
        !           634:          break;
        !           635:       }
        !           636:     verify_area (optlen, sizeof (int));
        !           637:     put_fs_long (sizeof(int),(unsigned long *) optlen);
        !           638: 
        !           639:     verify_area(optval, sizeof (int));
        !           640:     put_fs_long (val, (unsigned long *)optval);
        !           641:     return (0);
        !           642: }
        !           643: 
        !           644: static int
        !           645: ip_proto_listen(struct socket *sock, int backlog)
        !           646: {
        !           647:   volatile struct sock *sk;
        !           648:   sk = sock->data;
        !           649:    if (sk == NULL)
        !           650:      {
        !           651:        printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !           652:        return (0);
        !           653:      }
        !           654:   sk->state = TCP_LISTEN;
        !           655:   return (0);
        !           656: }
        !           657: 
        !           658: /* Hardware should be inited here. */
        !           659: static int ip_proto_init(void)
        !           660: {
        !           661:   int i;
        !           662:   struct device *dev;
        !           663:   struct ip_protocol *p;
        !           664:   seq_offset = CURRENT_TIME*250;
        !           665:   /* add all the protocols. */
        !           666:   for (i = 0; i < SOCK_ARRAY_SIZE; i++)
        !           667:     {
        !           668:        tcp_prot.sock_array[i] = NULL;
        !           669:        udp_prot.sock_array[i] = NULL;
        !           670:        raw_prot.sock_array[i] = NULL;
        !           671:     }
        !           672: 
        !           673:   for (p = ip_protocol_base; p != NULL;)
        !           674:     {
        !           675:        struct ip_protocol *tmp;
        !           676:        /* add all the protocols. */
        !           677:        tmp = p->next;
        !           678:        add_ip_protocol (p);
        !           679:        p = tmp;
        !           680:     }
        !           681: 
        !           682:   /* add the devices */
        !           683:   for (dev = dev_base; dev != NULL; dev=dev->next)
        !           684:     {
        !           685:        if (dev->init)
        !           686:         dev->init(dev);
        !           687:     }
        !           688:   timer_table[NET_TIMER].fn = net_timer;
        !           689:   return (0);
        !           690: }
        !           691: 
        !           692: static int
        !           693: ip_proto_create (struct socket *sock, int protocol)
        !           694: {
        !           695:   volatile struct sock *sk;
        !           696:   struct proto *prot;
        !           697:   int err;
        !           698: 
        !           699:   sk = malloc (sizeof (*sk));
        !           700:   if (sk == NULL)
        !           701:     return (-ENOMEM);
        !           702:   sk->num = 0;
        !           703: 
        !           704: 
        !           705:   switch (sock->type)
        !           706:     {
        !           707:     case SOCK_STREAM:
        !           708:     case SOCK_SEQPACKET:
        !           709:        if (protocol && protocol != IP_TCP)
        !           710:         {
        !           711:            free_s ((void *)sk, sizeof (*sk));
        !           712:            return (-EPROTONOSUPPORT);
        !           713:         }
        !           714:        sk->no_check = TCP_NO_CHECK;
        !           715:        prot = &tcp_prot;
        !           716:        break;
        !           717: 
        !           718:     case SOCK_DGRAM:
        !           719:        if (protocol && protocol != IP_UDP)
        !           720:         {
        !           721:            free_s ((void *)sk, sizeof (*sk));
        !           722:            return (-EPROTONOSUPPORT);
        !           723:         }
        !           724:        sk->no_check = UDP_NO_CHECK;
        !           725:        prot=&udp_prot;
        !           726:        break;
        !           727:       
        !           728:      case SOCK_RAW:
        !           729:        if (!suser())
        !           730:         {
        !           731:            free_s ((void *)sk, sizeof (*sk));
        !           732:            return (-EPERM);
        !           733:         }
        !           734: 
        !           735:        if (!protocol)
        !           736:         {
        !           737:            free_s ((void *)sk, sizeof (*sk));
        !           738:            return (-EPROTONOSUPPORT);
        !           739:         }
        !           740:        prot = &raw_prot;
        !           741:        sk->reuse = 1;
        !           742:        sk->no_check = 0; /* doesn't matter no checksum is preformed
        !           743:                            anyway. */
        !           744:        sk->num = protocol;
        !           745:        break;
        !           746: 
        !           747:     case SOCK_PACKET:
        !           748:        if (!suser())
        !           749:         {
        !           750:            free_s ((void *)sk, sizeof (*sk));
        !           751:            return (-EPERM);
        !           752:         }
        !           753: 
        !           754:        if (!protocol)
        !           755:         {
        !           756:            free_s ((void *)sk, sizeof (*sk));
        !           757:            return (-EPROTONOSUPPORT);
        !           758:         }
        !           759:        prot = &packet_prot;
        !           760:        sk->reuse = 1;
        !           761:        sk->no_check = 0; /* doesn't matter no checksum is preformed
        !           762:                            anyway. */
        !           763:        sk->num = protocol;
        !           764:        break;
        !           765: 
        !           766:       
        !           767:     default:
        !           768:        free_s ((void *)sk, sizeof (*sk));
        !           769:        return (-ESOCKTNOSUPPORT);
        !           770: 
        !           771:     }
        !           772:   sk->protocol = protocol;
        !           773:   sk->wmem_alloc = 0;
        !           774:   sk->rmem_alloc = 0;
        !           775:   sk->pair = NULL;
        !           776:   sk->opt = NULL;
        !           777:   sk->send_seq = 0;
        !           778:   sk->acked_seq = 0;
        !           779:   sk->copied_seq = 0;
        !           780:   sk->fin_seq = 0;
        !           781:   sk->proc = 0;
        !           782:   sk->rtt = TCP_WRITE_TIME;
        !           783:   sk->packets_out = 0;
        !           784:   sk->cong_window = 1; /* start with only sending one packet at a time. */
        !           785:   sk->exp_growth = 1;  /* if set cong_window grow exponentially every time
        !           786:                          we get an ack. */
        !           787:   sk->urginline = 0;
        !           788:   sk->intr = 0;
        !           789:   sk->linger = 0;
        !           790:   sk->destroy = 0;
        !           791:   sk->reuse = 0;
        !           792:   sk->priority = 1;
        !           793:   sk->shutdown = 0;
        !           794:   sk->urg = 0;
        !           795:   sk->keepopen = 0;
        !           796:   sk->done = 0;
        !           797:   sk->ack_backlog = 0;
        !           798:   sk->window = 0;
        !           799:   sk->bytes_rcv = 0;
        !           800:   sk->state = TCP_CLOSE;
        !           801:   sk->dead = 0;
        !           802:   sk->ack_timed = 0;
        !           803: 
        !           804:   /* this is how many unacked bytes we will accept for
        !           805:      this socket.  */
        !           806: 
        !           807:   sk->max_unacked = 2048; /* needs to be at most 2 full packets. */
        !           808: 
        !           809:   /* how many packets we should send before forcing an ack. 
        !           810:      if this is set to zero it is the same as sk->delay_acks = 0 */
        !           811: 
        !           812:   sk->max_ack_backlog = MAX_ACK_BACKLOG;
        !           813:   sk->inuse = 0;
        !           814:   sk->delay_acks = 1; /* default to waiting a while before sending
        !           815:                         acks.  */
        !           816:   sk->wback = NULL;
        !           817:   sk->wfront = NULL;
        !           818:   sk->rqueue = NULL;
        !           819:   sk->mtu = 576;
        !           820:   sk->prot = prot;
        !           821:   sk->sleep = sock->wait;
        !           822:   sk->daddr = 0;
        !           823:   sk->saddr = MY_IP_ADDR;
        !           824:   sk->err = 0;
        !           825:   sk->next = NULL;
        !           826:   sk->pair = NULL;
        !           827:   sk->send_tail = NULL;
        !           828:   sk->send_head = NULL;
        !           829:   sk->time_wait.len = TCP_CONNECT_TIME;
        !           830:   sk->time_wait.when = 0;
        !           831:   sk->time_wait.sk = sk;
        !           832:   sk->time_wait.next = NULL;
        !           833:   sk->timeout = 0;
        !           834:   sk->back_log = NULL;
        !           835:   sk->blog = 0;
        !           836:   sock->data =(void *) sk;
        !           837:   sk->dummy_th.doff = sizeof (sk->dummy_th)/4;
        !           838:   sk->dummy_th.res1=0;
        !           839:   sk->dummy_th.res2=0;
        !           840:   sk->dummy_th.urg_ptr = 0;
        !           841:   sk->dummy_th.fin = 0;
        !           842:   sk->dummy_th.syn = 0;
        !           843:   sk->dummy_th.rst = 0;
        !           844:   sk->dummy_th.psh = 0;
        !           845:   sk->dummy_th.ack = 0;
        !           846:   sk->dummy_th.urg = 0;
        !           847:   sk->dummy_th.dest = 0;
        !           848:   if (sk->num)
        !           849:     {
        !           850:        put_sock (sk->num, sk);
        !           851:     }
        !           852:   else
        !           853:     {
        !           854:        sk->num = get_new_socknum(sk->prot, 0);
        !           855:     }
        !           856:   /* make sure there was a free socket. */
        !           857:   if (sk->num == 0)
        !           858:     {
        !           859:       destroy_sock(sk);
        !           860:       return (-EAGAIN);
        !           861:     }
        !           862:   put_sock(sk->num, sk);
        !           863:   sk->dummy_th.source = net16(sk->num);
        !           864:   if (sk->prot->init)
        !           865:     {
        !           866:        err = sk->prot->init(sk);
        !           867:        if (err != 0)
        !           868:         {
        !           869:            destroy_sock (sk);
        !           870:            return (err);
        !           871:         }
        !           872:     }
        !           873:   return (0);
        !           874: }
        !           875: 
        !           876: static int
        !           877: ip_proto_dup (struct socket *newsock, struct socket *oldsock)
        !           878: {
        !           879:   return (ip_proto_create (newsock,
        !           880:                           ((volatile struct sock *)(oldsock->data))->protocol));
        !           881: }
        !           882: 
        !           883: /* the peer socket should always be NULL. */
        !           884: static int
        !           885: ip_proto_release(struct socket *sock, struct socket *peer)
        !           886: {
        !           887:   volatile struct sock *sk;
        !           888:   sk = sock->data;
        !           889:   if (sk == NULL) return (0);
        !           890:   wake_up (sk->sleep);
        !           891:   /* start closing the connection.  This may take a while. */
        !           892:   /* if linger is set, we don't return until the close is
        !           893:      complete.  Other wise we return immediately.  The
        !           894:      actually closing is done the same either way. */
        !           895:   if (sk->linger == 0)
        !           896:     {
        !           897:        sk->prot->close(sk,0);
        !           898:        sk->dead = 1;
        !           899:     }
        !           900:   else
        !           901:     {
        !           902:        sk->prot->close(sk, 0);
        !           903:        cli();
        !           904:        while (sk->state != TCP_CLOSE)
        !           905:         {
        !           906:            interruptible_sleep_on (sk->sleep);
        !           907:            if (current->signal & ~current->blocked)
        !           908:              {
        !           909:                 sti();
        !           910:                 return (-ERESTARTSYS);
        !           911:              }
        !           912:         }
        !           913:        sti();
        !           914:        sk->dead = 1;
        !           915:     }
        !           916: 
        !           917:   sk->inuse = 1;
        !           918:   /* this will destroy it. */
        !           919:   release_sock (sk);
        !           920:   sock->data = NULL;
        !           921:   return (0);
        !           922: }
        !           923: 
        !           924: 
        !           925: static int
        !           926: ip_proto_bind (struct socket *sock, struct sockaddr *uaddr,
        !           927:               int addr_len)
        !           928: {
        !           929:   struct sockaddr_in addr;
        !           930:   volatile struct sock *sk, *sk2;
        !           931:   unsigned short snum;
        !           932:   sk = sock->data;
        !           933:    if (sk == NULL)
        !           934:      {
        !           935:        printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !           936:        return (0);
        !           937:      }
        !           938:   /* check this error. */
        !           939:   if (sk->state != TCP_CLOSE) return (-EIO);
        !           940:   verify_area (uaddr, addr_len);
        !           941:   memcpy_fromfs (&addr, uaddr, min (sizeof (addr), addr_len));
        !           942:   if (addr.sin_family && addr.sin_family != AF_INET)
        !           943:     return (-EIO); /* this needs to be changed. */
        !           944:   snum = net16(addr.sin_port);
        !           945:   PRINTK ("bind sk =%X to port = %d\n", sk, snum);
        !           946:   print_sk (sk);
        !           947:   sk = sock->data;
        !           948: 
        !           949:   /* we can't just leave the socket bound wherever it is, it might be bound
        !           950:      to a priveledged port. However, since there seems to be a bug here,
        !           951:      we will leave it if the port is not priveledged(sp?) */
        !           952: 
        !           953:   if (snum == 0)
        !           954:     {
        !           955:        if ( sk->num > PROT_SOCK) return (0);
        !           956:        snum = get_new_socknum (sk->prot, 0);
        !           957:     }
        !           958: 
        !           959:   if (snum <= PROT_SOCK && !suser())
        !           960:     return (-EPERM);
        !           961: 
        !           962:   if (my_ip_addr(addr.sin_addr.s_addr) || addr.sin_addr.s_addr == 0)
        !           963:     sk->saddr = addr.sin_addr.s_addr;
        !           964:   PRINTK ("sock_array[%d] = %X:\n", snum & (SOCK_ARRAY_SIZE -1),
        !           965:          sk->prot->sock_array[snum & (SOCK_ARRAY_SIZE -1)]);
        !           966:   print_sk (sk->prot->sock_array[snum & (SOCK_ARRAY_SIZE -1)]);
        !           967: 
        !           968:   /* make sure we are allowed to bind here. */
        !           969:   for (sk2 = sk->prot->sock_array[snum & (SOCK_ARRAY_SIZE -1)];
        !           970:        sk2 != NULL;
        !           971:        sk2 = sk2->next)
        !           972:     {
        !           973:        if (sk2->num != snum) continue;
        !           974:        if (sk2->saddr != sk->saddr) continue;
        !           975:        if (!sk->reuse) return (-EADDRINUSE);
        !           976:        if (!sk2->reuse) return (-EADDRINUSE);
        !           977:     }
        !           978:   remove_sock (sk);
        !           979:   put_sock(snum, sk);
        !           980:   sk->dummy_th.source = net16(sk->num);
        !           981:   sk->daddr = 0;
        !           982:   sk->dummy_th.dest = 0;
        !           983:   return (0);
        !           984: }
        !           985: 
        !           986: static int
        !           987: ip_proto_connect (struct socket *sock, struct sockaddr * uaddr,
        !           988:                  int addr_len, int flags)
        !           989: {
        !           990:   volatile struct sock *sk;
        !           991:   int err;
        !           992:   sock->conn = NULL;
        !           993:   sk = sock->data;
        !           994:    if (sk == NULL)
        !           995:      {
        !           996:        printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !           997:        return (0);
        !           998:      }
        !           999:   if (sk->prot->connect == NULL)
        !          1000:     return (-EOPNOTSUPP);
        !          1001: 
        !          1002:   if (sk->intr == 0)
        !          1003:     {
        !          1004:       err = sk->prot->connect (sk, (struct sockaddr_in *)uaddr, addr_len);
        !          1005:       if (err < 0) return (err);
        !          1006:     }
        !          1007: 
        !          1008:   sock->state = SS_CONNECTED;
        !          1009: 
        !          1010:   if (flags & O_NONBLOCK) return (0);
        !          1011: 
        !          1012:   cli(); /* avoid the race condition */
        !          1013: 
        !          1014:   while (sk->state != TCP_ESTABLISHED && sk->state < TCP_CLOSING)
        !          1015:     {
        !          1016:       interruptible_sleep_on (sk->sleep);
        !          1017:       if (current->signal & ~current->blocked)
        !          1018:        {
        !          1019:           sti();
        !          1020:           sk->intr = 1;
        !          1021:           return (-ERESTARTSYS);
        !          1022:        }
        !          1023:     }
        !          1024:   sti();
        !          1025:   sk->intr = 0;
        !          1026:   if (sk->state != TCP_ESTABLISHED && sk->err)
        !          1027:     {
        !          1028:       return (-sk->err);
        !          1029:     }
        !          1030:   return (0);
        !          1031: }
        !          1032: 
        !          1033: static int
        !          1034: ip_proto_socketpair (struct socket *sock1, struct socket *sock2)
        !          1035: {
        !          1036:   return (-EOPNOTSUPP);
        !          1037: }
        !          1038: 
        !          1039: static int
        !          1040: ip_proto_accept (struct socket *sock, struct socket *newsock, int flags)
        !          1041: {
        !          1042:   volatile struct sock *sk1, *sk2;
        !          1043:   sk1= sock->data;
        !          1044:    if (sk1 == NULL)
        !          1045:      {
        !          1046:        printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !          1047:        return (0);
        !          1048:      }
        !          1049:   newsock->data = NULL;
        !          1050:   if (sk1->prot->accept == NULL) return (-EOPNOTSUPP);
        !          1051:   /* restore the state if we have been interrupted, and
        !          1052:      then returned. */
        !          1053:   if (sk1->pair != NULL )
        !          1054:     {
        !          1055:       sk2 = sk1->pair;
        !          1056:       sk1->pair = NULL;
        !          1057:     }
        !          1058:   else
        !          1059:     {
        !          1060:       sk2 = sk1->prot->accept (sk1,flags);
        !          1061:       if (sk2 == NULL)
        !          1062:        return (-sk1->err);
        !          1063:     }
        !          1064:   newsock->data = (void *)sk2;
        !          1065:   sk2->sleep = (void *)newsock->wait;
        !          1066:   newsock->conn = NULL;
        !          1067:   if (flags & O_NONBLOCK)
        !          1068:     return (0);
        !          1069: 
        !          1070:   cli(); /* avoid the race. */
        !          1071:   while (sk2->state == TCP_SYN_RECV)
        !          1072:     {
        !          1073:       interruptible_sleep_on (sk2->sleep);
        !          1074:       if (current->signal & ~current->blocked)
        !          1075:        {
        !          1076:           sti();
        !          1077:           sk1->pair = sk2;
        !          1078:           sk2->sleep = NULL;
        !          1079:           newsock->data = NULL;
        !          1080:           return (-ERESTARTSYS);
        !          1081:        }
        !          1082:     }
        !          1083:   sti();
        !          1084: 
        !          1085:   if (sk2->state != TCP_ESTABLISHED && sk2->err)
        !          1086:     {
        !          1087:       int err;
        !          1088:       err = -sk2->err;
        !          1089:       destroy_sock (sk2);
        !          1090:       newsock->data = NULL;
        !          1091:       return (err);
        !          1092:     }
        !          1093:   newsock->state = SS_CONNECTED;
        !          1094:   return (0);
        !          1095: }
        !          1096: 
        !          1097: static int
        !          1098: ip_proto_getname(struct socket *sock, struct sockaddr *uaddr,
        !          1099:                 int *uaddr_len, int peer)
        !          1100: {
        !          1101:   struct sockaddr_in sin;
        !          1102:   volatile struct sock *sk;
        !          1103:   int len;
        !          1104:   verify_area(uaddr_len, sizeof (len));
        !          1105:   len = get_fs_long(uaddr_len);
        !          1106:   /* check this error. */
        !          1107:   if (len < sizeof (sin)) return (-EINVAL);
        !          1108:   verify_area (uaddr, len);
        !          1109:   sin.sin_family=AF_INET;
        !          1110:   sk = sock->data;
        !          1111:   if (sk == NULL)
        !          1112:     {
        !          1113:        printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !          1114:        return (0);
        !          1115:     }
        !          1116:   if (peer)
        !          1117:     {
        !          1118:       if (sk->state != TCP_ESTABLISHED)
        !          1119:        return (-ENOTCONN);
        !          1120:       sin.sin_port = sk->dummy_th.dest;
        !          1121:       sin.sin_addr.s_addr = sk->daddr;
        !          1122:       }
        !          1123:   else
        !          1124:     {
        !          1125:       sin.sin_port = sk->dummy_th.source;
        !          1126:       sin.sin_addr.s_addr = sk->saddr;
        !          1127:     }
        !          1128:   len = sizeof (sin);
        !          1129:   memcpy_tofs(uaddr, &sin, sizeof (sin));
        !          1130:   put_fs_long (len, uaddr_len);
        !          1131:   return (0);
        !          1132: }
        !          1133: 
        !          1134: static int
        !          1135: ip_proto_read (struct socket *sock, char *ubuf, int size, int noblock)
        !          1136: {
        !          1137:   volatile struct sock *sk;
        !          1138:   sk = sock->data;
        !          1139:    if (sk == NULL)
        !          1140:      {
        !          1141:        printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !          1142:        return (0);
        !          1143:      }
        !          1144:   if (sk->shutdown & RCV_SHUTDOWN)
        !          1145:     return (-EIO);
        !          1146:   return (sk->prot->read (sk, ubuf, size, noblock,0));
        !          1147: }
        !          1148: 
        !          1149: static int
        !          1150: ip_proto_recv (struct socket *sock, void *ubuf, int size, int noblock,
        !          1151:               unsigned flags)
        !          1152: {
        !          1153:   volatile struct sock *sk;
        !          1154:   sk = sock->data;
        !          1155:    if (sk == NULL)
        !          1156:      {
        !          1157:        printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !          1158:        return (0);
        !          1159:      }
        !          1160:   if (sk->shutdown & RCV_SHUTDOWN)
        !          1161:     return (-EIO);
        !          1162:   return (sk->prot->read (sk, ubuf, size, noblock, flags));
        !          1163: }
        !          1164: 
        !          1165: static int
        !          1166: ip_proto_write (struct socket *sock, char *ubuf, int size, int noblock)
        !          1167: {
        !          1168:   volatile struct sock *sk;
        !          1169:   sk = sock->data;
        !          1170:    if (sk == NULL)
        !          1171:      {
        !          1172:        printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !          1173:        return (0);
        !          1174:      }
        !          1175:   if (sk->shutdown & SEND_SHUTDOWN)
        !          1176:     return (-EIO);
        !          1177:   return (sk->prot->write (sk, ubuf, size, noblock, 0));
        !          1178: }
        !          1179: 
        !          1180: 
        !          1181: static int
        !          1182: ip_proto_send (struct socket *sock, void *ubuf, int size, int noblock, 
        !          1183:               unsigned flags)
        !          1184: {
        !          1185:   volatile struct sock *sk;
        !          1186:   sk = sock->data;
        !          1187:    if (sk == NULL)
        !          1188:      {
        !          1189:        printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !          1190:        return (0);
        !          1191:      }
        !          1192:   if (sk->shutdown & SEND_SHUTDOWN)
        !          1193:     return (-EIO);
        !          1194:   return (sk->prot->write (sk, ubuf, size, noblock, flags));
        !          1195: }
        !          1196: 
        !          1197: 
        !          1198: static int
        !          1199: ip_proto_sendto (struct socket *sock, void *ubuf, int size, int noblock, 
        !          1200:                 unsigned flags, struct sockaddr *sin, int addr_len )
        !          1201: {
        !          1202:   volatile struct sock *sk;
        !          1203:   sk = sock->data;
        !          1204:    if (sk == NULL)
        !          1205:      {
        !          1206:        printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !          1207:        return (0);
        !          1208:      }
        !          1209:   if (sk->shutdown & SEND_SHUTDOWN)
        !          1210:     return (-EIO);
        !          1211:   if (sk->prot->sendto == NULL) return (-EOPNOTSUPP);
        !          1212:   return (sk->prot->sendto (sk, ubuf, size, noblock, flags, 
        !          1213:                            (struct sockaddr_in *)sin, addr_len));
        !          1214: }
        !          1215: 
        !          1216: static int
        !          1217: ip_proto_recvfrom (struct socket *sock, void *ubuf, int size, int noblock, 
        !          1218:                   unsigned flags, struct sockaddr *sin, int *addr_len )
        !          1219: {
        !          1220:   volatile struct sock *sk;
        !          1221:   sk = sock->data;
        !          1222:    if (sk == NULL)
        !          1223:      {
        !          1224:        printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !          1225:        return (0);
        !          1226:      }
        !          1227:   if (sk->shutdown & RCV_SHUTDOWN)
        !          1228:     return (-EIO);
        !          1229:   if (sk->prot->recvfrom == NULL) return (-EOPNOTSUPP);
        !          1230:   return (sk->prot->recvfrom (sk, ubuf, size, noblock, flags,
        !          1231:                              (struct sockaddr_in*)sin, addr_len));
        !          1232: }
        !          1233: 
        !          1234: static int
        !          1235: ip_proto_shutdown (struct socket *sock, int how)
        !          1236: {
        !          1237:        volatile struct sock *sk;
        !          1238:        /* this should really check to make sure the socket is
        !          1239:           a tcp socket. */
        !          1240:        how++; /* maps 0->1 has the advantage of making bit 1 rcvs and
        !          1241:                       1->2 bit 2 snds.
        !          1242:                       2->3 */
        !          1243:        if (how & ~SHUTDOWN_MASK) return (-EINVAL);
        !          1244:        sk = sock->data;
        !          1245:        if (sk == NULL)
        !          1246:          {
        !          1247:             printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !          1248:             return (0);
        !          1249:          }
        !          1250:        if (sk->state != TCP_ESTABLISHED) return (-ENOTCONN);
        !          1251:        sk->shutdown |= how;
        !          1252:        return (0);
        !          1253: }
        !          1254: 
        !          1255: static int
        !          1256: ip_proto_select (struct socket *sock, int sel_type, select_table *wait )
        !          1257: {
        !          1258:   volatile struct sock *sk;
        !          1259:   sk = sock->data;
        !          1260:    if (sk == NULL)
        !          1261:      {
        !          1262:        printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !          1263:        return (0);
        !          1264:      }
        !          1265: 
        !          1266:   if (sk->prot->select == NULL)
        !          1267:     {
        !          1268:        PRINTK ("select on non-selectable socket. \n");
        !          1269:        return (0);
        !          1270:     }
        !          1271:   return (sk->prot->select(sk, sel_type, wait));
        !          1272: }
        !          1273: 
        !          1274: /* these should be distributed to the different protocol routines. */
        !          1275: static int
        !          1276: ip_proto_ioctl (struct socket *sock, unsigned int cmd, 
        !          1277:                unsigned long arg)
        !          1278: {
        !          1279:    volatile struct sock *sk;
        !          1280:    sk = sock->data;
        !          1281:    if (sk == NULL)
        !          1282:      {
        !          1283:        printk ("Warning: sock->data = NULL: %d\n" ,__LINE__);
        !          1284:        return (0);
        !          1285:      }
        !          1286: 
        !          1287:   PRINTK ("in ip_proto_ioctl\n");
        !          1288:   switch (cmd)
        !          1289:     {
        !          1290: 
        !          1291:       case IP_SET_DEV:
        !          1292:        if (!suser())
        !          1293:         return (-EPERM);
        !          1294:        return (ip_set_dev((struct ip_config *)arg));
        !          1295: #if 0
        !          1296:     case IP_ADD_ROUTE:
        !          1297:       ip_add_route ((struct rtable *) arg);
        !          1298:       return (0);
        !          1299: #endif
        !          1300:     default:
        !          1301:        if (!sk->prot->ioctl)
        !          1302:         return (-EINVAL);
        !          1303:        return (sk->prot->ioctl (sk, cmd, arg));
        !          1304:     }
        !          1305: }
        !          1306: 
        !          1307: #ifdef MEM_DEBUG
        !          1308: 
        !          1309: struct mem
        !          1310: {
        !          1311:    unsigned long check;
        !          1312:    struct mem *other;
        !          1313:    unsigned long len;
        !          1314:    unsigned short buff[10];
        !          1315: };
        !          1316: 
        !          1317: static void
        !          1318: print_mem (struct mem *m)
        !          1319: {
        !          1320:    int i;
        !          1321:    MPRINTK("mem:\n");
        !          1322:    MPRINTK("  check=%X, other = %X\n", m->check, m->other);
        !          1323:    MPRINTK("  len=%d buff:\n " , m->len);
        !          1324:    for (i = 0; i < 10; i++)
        !          1325:      {
        !          1326:        MPRINTK ("0x%02X ",m->buff[i]);
        !          1327:      }
        !          1328:    MPRINTK ("\n");
        !          1329: }
        !          1330: 
        !          1331: static void *
        !          1332: smalloc (unsigned long size)
        !          1333: {
        !          1334:    struct mem *head, *tail;
        !          1335:    static unsigned short count;
        !          1336:    int i;
        !          1337:    int sum;
        !          1338:    unsigned char *ptr;
        !          1339: 
        !          1340:    MPRINTK ("smalloc (size = %d)\n",size);
        !          1341:    head = malloc (size + 2*sizeof (*head));
        !          1342:    if (head == NULL) return (NULL);
        !          1343:    tail = (struct mem *)((unsigned char *)(head+1) + size); 
        !          1344: 
        !          1345:    head->other = tail;
        !          1346:    tail->other = head;
        !          1347: 
        !          1348:    tail->len = size;
        !          1349:    head->len = size;
        !          1350:    for (i = 0; i < 10; i++)
        !          1351:      {
        !          1352:        tail->buff[i]=count++;
        !          1353:        head->buff[i]=count;
        !          1354:      }
        !          1355: 
        !          1356:    ptr = (unsigned char *)head;
        !          1357:    head->check = 0;
        !          1358:    sum = 0;
        !          1359: 
        !          1360:    for (i = 0; i < sizeof (*head); i ++)
        !          1361:      {
        !          1362:        sum+= ptr[i]; 
        !          1363:      }
        !          1364: 
        !          1365:    head->check = ~sum;
        !          1366:    ptr = (unsigned char *)tail;
        !          1367:    tail->check = 0;
        !          1368:    sum = 0;
        !          1369: 
        !          1370:    for (i = 0; i < sizeof (*head); i ++)
        !          1371:      {
        !          1372:        sum+= ptr[i]; 
        !          1373:      }
        !          1374: 
        !          1375:    tail->check = ~sum;
        !          1376:    MPRINTK ("head = %X:\n", head);
        !          1377:    print_mem(head);
        !          1378:    MPRINTK ("tail = %X:\n", tail);
        !          1379:    print_mem(tail);
        !          1380:    return (head+1);
        !          1381: }
        !          1382: 
        !          1383: void
        !          1384: sfree (void *data, unsigned long len)
        !          1385: {
        !          1386:    int i;
        !          1387:    int sum;
        !          1388:    int csum;
        !          1389:    unsigned char *ptr;
        !          1390:    int bad = 0;
        !          1391:    struct mem *head, *tail;
        !          1392:    MPRINTK ("sfree(data=%X, len = %d)\n", data, len);
        !          1393:    head = data;
        !          1394:    head--;
        !          1395:    tail = (struct mem *)((unsigned char *)(head+1) + len);
        !          1396:    print_mem (head);
        !          1397:    print_mem (tail);
        !          1398:    if (head->other != tail)
        !          1399:      {
        !          1400:        MPRINTK ("sfree: head->other != tail:\n");
        !          1401:        bad = 1;
        !          1402:      }
        !          1403:    if (tail->other != head)
        !          1404:      {
        !          1405:        MPRINTK ("sfree: tail->other != head:\n");
        !          1406:        bad =1 ;
        !          1407:      }
        !          1408:    if (head ->len != len)
        !          1409:      {
        !          1410:        MPRINTK ("sfree: head->len != len");
        !          1411:        bad = 1;
        !          1412:      }
        !          1413:    if (tail ->len != len)
        !          1414:      {
        !          1415:        MPRINTK ("sfree: tail->len != len");
        !          1416:        bad = 1;
        !          1417:      }
        !          1418:    csum = head->check;
        !          1419:    ptr = (unsigned char *)head;
        !          1420:    head->check = 0;
        !          1421:    sum = 0;
        !          1422:    for (i = 0; i < sizeof (*head); i ++)
        !          1423:      {
        !          1424:        sum+= ptr[i]; 
        !          1425:      }
        !          1426:    if (csum != ~sum)
        !          1427:      {
        !          1428:        MPRINTK ("sfree: head failed checksum\n");
        !          1429:        bad = 1;
        !          1430:      }
        !          1431:    csum = tail->check;
        !          1432:    ptr = (unsigned char *)tail;
        !          1433:    tail->check = 0;
        !          1434:    sum = 0;
        !          1435:    for (i = 0; i < sizeof (*head); i ++)
        !          1436:      {
        !          1437:        sum+= ptr[i]; 
        !          1438:      }
        !          1439:    if (csum != ~sum)
        !          1440:      {
        !          1441:        MPRINTK ("sfree: tail failed checksum\n");
        !          1442:        bad = 1;
        !          1443:      }
        !          1444:    if (!bad)
        !          1445:      free_s (head, len+2*sizeof (*head));
        !          1446:    else
        !          1447:      schedule();
        !          1448: }
        !          1449: #else
        !          1450: static  void *
        !          1451: smalloc (unsigned long size)
        !          1452: {
        !          1453:    return (malloc (size));
        !          1454: }
        !          1455: static  void
        !          1456: sfree(void *data, unsigned long len)
        !          1457: {
        !          1458:    free_s(data,len);
        !          1459: }
        !          1460: #endif
        !          1461: 
        !          1462: void *
        !          1463: sock_wmalloc(volatile struct sock *sk, unsigned long size, int force)
        !          1464: {
        !          1465:   void *tmp;
        !          1466:   if (sk)
        !          1467:     {
        !          1468:        if (sk->wmem_alloc + size >= SK_WMEM_MAX && !force)
        !          1469:         {
        !          1470:            MPRINTK ("sock_wmalloc(%X,%d,%d) returning NULL\n",
        !          1471:                     sk, size, force);
        !          1472:            return (NULL);
        !          1473:         }
        !          1474:       cli();
        !          1475:       sk->wmem_alloc+= size;
        !          1476:       sti();
        !          1477:     }
        !          1478:    if (sk)
        !          1479:      tmp = smalloc (size);
        !          1480:    else
        !          1481:      tmp = malloc (size);
        !          1482: 
        !          1483:   MPRINTK ("sock_wmalloc(%X,%d,%d) returning %X\n",sk, size, force, tmp);
        !          1484:   return (tmp);
        !          1485: }
        !          1486: 
        !          1487: void *
        !          1488: sock_rmalloc(volatile struct sock *sk, unsigned long size, int force)
        !          1489: {
        !          1490:    struct mem *tmp;
        !          1491:    if (sk )
        !          1492:      {
        !          1493:        if (sk->rmem_alloc + size >= SK_RMEM_MAX && !force)
        !          1494:          {
        !          1495:             MPRINTK ("sock_rmalloc(%X,%d,%d) returning NULL\n",sk,size,force);
        !          1496:             return (NULL);
        !          1497:          }
        !          1498:        cli();
        !          1499:        sk->rmem_alloc+= size;
        !          1500:        sti();
        !          1501:      }
        !          1502:    if (sk)
        !          1503:      tmp = smalloc (size);
        !          1504:    else
        !          1505:      tmp = malloc (size);
        !          1506: 
        !          1507:    MPRINTK ("sock_rmalloc(%X,%d,%d) returning %X\n",sk, size, force, tmp);
        !          1508:    return (tmp);
        !          1509: }
        !          1510: 
        !          1511: 
        !          1512: unsigned long
        !          1513: sock_rspace (volatile struct sock *sk)
        !          1514: {
        !          1515:    int amt;
        !          1516:    if (sk != NULL)
        !          1517:      {
        !          1518:        if (sk->rmem_alloc >= SK_RMEM_MAX-2*MIN_WINDOW) return (0);
        !          1519:        amt = min ((SK_RMEM_MAX-sk->rmem_alloc)/2-MIN_WINDOW, MAX_WINDOW);
        !          1520:        if (amt < 0) return (0);
        !          1521:        return (amt);
        !          1522:      }
        !          1523:    return (0);
        !          1524: }
        !          1525: 
        !          1526: unsigned long
        !          1527: sock_wspace (volatile struct sock *sk)
        !          1528: {
        !          1529:   if (sk != NULL)
        !          1530:     {
        !          1531:        if (sk->shutdown & SEND_SHUTDOWN) return (0);
        !          1532:        if (sk->wmem_alloc >= SK_WMEM_MAX) return (0);
        !          1533:        return (SK_WMEM_MAX-sk->wmem_alloc );
        !          1534:     }
        !          1535:   return (0);
        !          1536: }
        !          1537: 
        !          1538: 
        !          1539: void
        !          1540: sock_wfree (volatile struct sock *sk, void *mem, unsigned long size)
        !          1541: {
        !          1542:    MPRINTK ("sock_wfree (sk=%X, mem=%X, size=%d)\n",sk, mem, size);
        !          1543:    if (sk)
        !          1544:      {
        !          1545:        sk->wmem_alloc -= size;
        !          1546:        sfree(mem,size);
        !          1547:        /* in case it might be waiting for more memory. */
        !          1548:        if (!sk->dead && sk->wmem_alloc > SK_WMEM_MAX/2) wake_up(sk->sleep);
        !          1549:        if (sk->destroy && sk->wmem_alloc == 0 && sk->rmem_alloc == 0)
        !          1550:          {
        !          1551:             MPRINTK ("recovered lost memory, destroying sock = %X\n",sk);
        !          1552:             delete_timer ((struct timer *)&sk->time_wait);
        !          1553:             free_s ((void *)sk, sizeof (*sk));
        !          1554:          }
        !          1555:      }
        !          1556:    else
        !          1557:      {
        !          1558:        free_s (mem, size);
        !          1559:      }
        !          1560: }
        !          1561: 
        !          1562: void
        !          1563: sock_rfree (volatile struct sock *sk, void *mem, unsigned long size)
        !          1564: {
        !          1565:    MPRINTK ("sock_rfree (sk=%X, mem=%X, size=%d)\n",sk, mem, size);
        !          1566:    if (sk)
        !          1567:      {
        !          1568:        sk->rmem_alloc -= size;
        !          1569:        sfree(mem,size);
        !          1570:        if (sk->destroy && sk->wmem_alloc == 0 && sk->rmem_alloc == 0)
        !          1571:          {
        !          1572:             delete_timer ((struct timer *)&sk->time_wait);
        !          1573:             free_s ((void *)sk, sizeof (*sk));
        !          1574:          }
        !          1575:      }
        !          1576:    else
        !          1577:      {
        !          1578:        free_s (mem, size);
        !          1579:      }
        !          1580: }
        !          1581: 
        !          1582: 
        !          1583: /* This routine must find a socket given a tcp header.  Everyhting
        !          1584:    is assumed to be in net order. */
        !          1585: 
        !          1586: volatile struct sock *get_sock (struct proto *prot, unsigned short num,
        !          1587:                                unsigned long raddr,
        !          1588:                                unsigned short rnum, unsigned long laddr)
        !          1589: {
        !          1590:   volatile struct sock *s;
        !          1591:   PRINTK ("get_sock (prot=%X, num=%d, raddr=%X, rnum=%d, laddr=%X)\n",
        !          1592:          prot, num, raddr, rnum, laddr);
        !          1593: 
        !          1594:   /* SOCK_ARRAY_SIZE must be a power of two.  This will work better
        !          1595:      than a prime unless 3 or more sockets end up using the same
        !          1596:      array entry.  This should not be a problem because most
        !          1597:      well known sockets don't overlap that much, and for
        !          1598:      the other ones, we can just be careful about picking our
        !          1599:      socket number when we choose an arbitrary one. */
        !          1600: 
        !          1601:   for (s=prot->sock_array[num&(SOCK_ARRAY_SIZE-1)]; s != NULL; s=s->next)
        !          1602:     {
        !          1603:       if (s->num == num)
        !          1604:        {
        !          1605:          /* we need to see if this is the socket that we want. */
        !          1606:          if (!ip_addr_match (s->daddr, raddr))
        !          1607:            continue;
        !          1608:          if (s->dummy_th.dest != rnum && s->dummy_th.dest != 0)
        !          1609:            continue;
        !          1610:          if (!ip_addr_match (s->saddr, laddr))
        !          1611:            continue;
        !          1612:          return (s);
        !          1613:        }
        !          1614:     }
        !          1615:   return (NULL);
        !          1616: }
        !          1617: 
        !          1618: void release_sock (volatile struct sock *sk)
        !          1619: {
        !          1620:   if (sk->blog) return;
        !          1621:   /* see if we have any packets built up. */
        !          1622: 
        !          1623:   cli();
        !          1624:   sk->inuse = 1;
        !          1625:   while (sk->back_log != NULL)
        !          1626:     {
        !          1627:       struct sk_buff *skb;
        !          1628:       sk->blog = 1;
        !          1629:       skb = sk->back_log;
        !          1630:       PRINTK ("release_sock: skb = %X:\n",skb);
        !          1631:       print_skb(skb);
        !          1632:       if (skb->next != skb)
        !          1633:        {
        !          1634:          sk->back_log = skb->next;
        !          1635:          skb->prev->next = skb->next;
        !          1636:          skb->next->prev = skb->prev;
        !          1637:        }
        !          1638:       else
        !          1639:        {
        !          1640:          sk->back_log = NULL;
        !          1641:        }
        !          1642:       sti();
        !          1643:       PRINTK ("sk->back_log = %X\n",sk->back_log);
        !          1644:       if (sk->prot->rcv)
        !          1645:        sk->prot->rcv(skb, skb->dev, sk->opt,
        !          1646:                      skb->saddr, skb->len, skb->daddr, 1,
        !          1647:                      /* only used for/by raw sockets. */
        !          1648:                      (struct ip_protocol *)sk->pair); 
        !          1649:       cli();
        !          1650:     }
        !          1651:   sk->blog = 0;
        !          1652:   sk->inuse = 0;
        !          1653:   sti();
        !          1654:   if (sk->dead && sk->state == TCP_CLOSE)
        !          1655:     {
        !          1656:         /* should be about 2 rtt's */
        !          1657:        sk->time_wait.len = min (sk->rtt * 2, TCP_DONE_TIME);
        !          1658:        sk->timeout = TIME_DONE;
        !          1659:        reset_timer ((struct timer *)&sk->time_wait);
        !          1660:     }
        !          1661: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.