net: Don't copy every packet that waits for an ARP
[platform/kernel/u-boot.git] / include / net.h
1 /*
2  *      LiMon Monitor (LiMon) - Network.
3  *
4  *      Copyright 1994 - 2000 Neil Russell.
5  *      (See License)
6  *
7  *
8  * History
9  *      9/16/00   bor  adapted to TQM823L/STK8xxL board, RARP/TFTP boot added
10  */
11
12 #ifndef __NET_H__
13 #define __NET_H__
14
15 #if defined(CONFIG_8xx)
16 #include <commproc.h>
17 #endif  /* CONFIG_8xx */
18
19 #include <asm/cache.h>
20 #include <asm/byteorder.h>      /* for nton* / ntoh* stuff */
21
22
23 /*
24  *      The number of receive packet buffers, and the required packet buffer
25  *      alignment in memory.
26  *
27  */
28
29 #ifdef CONFIG_SYS_RX_ETH_BUFFER
30 # define PKTBUFSRX      CONFIG_SYS_RX_ETH_BUFFER
31 #else
32 # define PKTBUFSRX      4
33 #endif
34
35 #define PKTALIGN        ARCH_DMA_MINALIGN
36
37 /* IPv4 addresses are always 32 bits in size */
38 typedef u32             IPaddr_t;
39
40
41 /**
42  * An incoming packet handler.
43  * @param pkt    pointer to the application packet
44  * @param dport  destination UDP port
45  * @param sip    source IP address
46  * @param sport  source UDP port
47  * @param len    packet length
48  */
49 typedef void rxhand_f(uchar *pkt, unsigned dport,
50                       IPaddr_t sip, unsigned sport,
51                       unsigned len);
52
53 /**
54  * An incoming ICMP packet handler.
55  * @param type  ICMP type
56  * @param code  ICMP code
57  * @param dport destination UDP port
58  * @param sip   source IP address
59  * @param sport source UDP port
60  * @param pkt   pointer to the ICMP packet data
61  * @param len   packet length
62  */
63 typedef void rxhand_icmp_f(unsigned type, unsigned code, unsigned dport,
64                 IPaddr_t sip, unsigned sport, uchar *pkt, unsigned len);
65
66 /*
67  *      A timeout handler.  Called after time interval has expired.
68  */
69 typedef void    thand_f(void);
70
71 enum eth_state_t {
72         ETH_STATE_INIT,
73         ETH_STATE_PASSIVE,
74         ETH_STATE_ACTIVE
75 };
76
77 struct eth_device {
78         char name[16];
79         unsigned char enetaddr[6];
80         int iobase;
81         int state;
82
83         int  (*init) (struct eth_device *, bd_t *);
84         int  (*send) (struct eth_device *, void *packet, int length);
85         int  (*recv) (struct eth_device *);
86         void (*halt) (struct eth_device *);
87 #ifdef CONFIG_MCAST_TFTP
88         int (*mcast) (struct eth_device *, u32 ip, u8 set);
89 #endif
90         int  (*write_hwaddr) (struct eth_device *);
91         struct eth_device *next;
92         int index;
93         void *priv;
94 };
95
96 extern int eth_initialize(bd_t *bis);   /* Initialize network subsystem */
97 extern int eth_register(struct eth_device* dev);/* Register network device */
98 extern int eth_unregister(struct eth_device *dev);/* Remove network device */
99 extern void eth_try_another(int first_restart); /* Change the device */
100 extern void eth_set_current(void);              /* set nterface to ethcur var */
101 extern struct eth_device *eth_get_dev(void);    /* get the current device MAC */
102 extern struct eth_device *eth_get_dev_by_name(const char *devname);
103 extern struct eth_device *eth_get_dev_by_index(int index); /* get dev @ index */
104 extern int eth_get_dev_index(void);             /* get the device index */
105 extern void eth_parse_enetaddr(const char *addr, uchar *enetaddr);
106 extern int eth_getenv_enetaddr(char *name, uchar *enetaddr);
107 extern int eth_setenv_enetaddr(char *name, const uchar *enetaddr);
108
109 /*
110  * Get the hardware address for an ethernet interface .
111  * Args:
112  *      base_name - base name for device (normally "eth")
113  *      index - device index number (0 for first)
114  *      enetaddr - returns 6 byte hardware address
115  * Returns:
116  *      Return true if the address is valid.
117  */
118 extern int eth_getenv_enetaddr_by_index(const char *base_name, int index,
119                                         uchar *enetaddr);
120
121 extern int usb_eth_initialize(bd_t *bi);
122 extern int eth_init(bd_t *bis);                 /* Initialize the device */
123 extern int eth_send(void *packet, int length);     /* Send a packet */
124
125 #ifdef CONFIG_API
126 extern int eth_receive(void *packet, int length); /* Receive a packet*/
127 extern void (*push_packet)(void *packet, int length);
128 #endif
129 extern int eth_rx(void);                        /* Check for received packets */
130 extern void eth_halt(void);                     /* stop SCC */
131 extern char *eth_get_name(void);                /* get name of current device */
132
133 /*
134  * Set the hardware address for an ethernet interface based on 'eth%daddr'
135  * environment variable (or just 'ethaddr' if eth_number is 0).
136  * Args:
137  *      base_name - base name for device (normally "eth")
138  *      eth_number - value of %d (0 for first device of this type)
139  * Returns:
140  *      0 is success, non-zero is error status from driver.
141  */
142 int eth_write_hwaddr(struct eth_device *dev, const char *base_name,
143                      int eth_number);
144
145 #ifdef CONFIG_MCAST_TFTP
146 int eth_mcast_join(IPaddr_t mcast_addr, u8 join);
147 u32 ether_crc(size_t len, unsigned char const *p);
148 #endif
149
150
151 /**********************************************************************/
152 /*
153  *      Protocol headers.
154  */
155
156 /*
157  *      Ethernet header
158  */
159
160 struct ethernet_hdr {
161         uchar           et_dest[6];     /* Destination node             */
162         uchar           et_src[6];      /* Source node                  */
163         ushort          et_protlen;     /* Protocol or length           */
164 };
165
166 /* Ethernet header size */
167 #define ETHER_HDR_SIZE  (sizeof(struct ethernet_hdr))
168
169 struct e802_hdr {
170         uchar           et_dest[6];     /* Destination node             */
171         uchar           et_src[6];      /* Source node                  */
172         ushort          et_protlen;     /* Protocol or length           */
173         uchar           et_dsap;        /* 802 DSAP                     */
174         uchar           et_ssap;        /* 802 SSAP                     */
175         uchar           et_ctl;         /* 802 control                  */
176         uchar           et_snap1;       /* SNAP                         */
177         uchar           et_snap2;
178         uchar           et_snap3;
179         ushort          et_prot;        /* 802 protocol                 */
180 };
181
182 /* 802 + SNAP + ethernet header size */
183 #define E802_HDR_SIZE   (sizeof(struct e802_hdr))
184
185 /*
186  *      Virtual LAN Ethernet header
187  */
188 struct vlan_ethernet_hdr {
189         uchar           vet_dest[6];    /* Destination node             */
190         uchar           vet_src[6];     /* Source node                  */
191         ushort          vet_vlan_type;  /* PROT_VLAN                    */
192         ushort          vet_tag;        /* TAG of VLAN                  */
193         ushort          vet_type;       /* protocol type                */
194 };
195
196 /* VLAN Ethernet header size */
197 #define VLAN_ETHER_HDR_SIZE     (sizeof(struct vlan_ethernet_hdr))
198
199 #define PROT_IP         0x0800          /* IP protocol                  */
200 #define PROT_ARP        0x0806          /* IP ARP protocol              */
201 #define PROT_RARP       0x8035          /* IP ARP protocol              */
202 #define PROT_VLAN       0x8100          /* IEEE 802.1q protocol         */
203
204 #define IPPROTO_ICMP     1      /* Internet Control Message Protocol    */
205 #define IPPROTO_UDP     17      /* User Datagram Protocol               */
206
207 /*
208  *      Internet Protocol (IP) header.
209  */
210 struct ip_hdr {
211         uchar           ip_hl_v;        /* header length and version    */
212         uchar           ip_tos;         /* type of service              */
213         ushort          ip_len;         /* total length                 */
214         ushort          ip_id;          /* identification               */
215         ushort          ip_off;         /* fragment offset field        */
216         uchar           ip_ttl;         /* time to live                 */
217         uchar           ip_p;           /* protocol                     */
218         ushort          ip_sum;         /* checksum                     */
219         IPaddr_t        ip_src;         /* Source IP address            */
220         IPaddr_t        ip_dst;         /* Destination IP address       */
221 };
222
223 #define IP_OFFS         0x1fff /* ip offset *= 8 */
224 #define IP_FLAGS        0xe000 /* first 3 bits */
225 #define IP_FLAGS_RES    0x8000 /* reserved */
226 #define IP_FLAGS_DFRAG  0x4000 /* don't fragments */
227 #define IP_FLAGS_MFRAG  0x2000 /* more fragments */
228
229 #define IP_HDR_SIZE             (sizeof(struct ip_hdr))
230
231 /*
232  *      Internet Protocol (IP) + UDP header.
233  */
234 struct ip_udp_hdr {
235         uchar           ip_hl_v;        /* header length and version    */
236         uchar           ip_tos;         /* type of service              */
237         ushort          ip_len;         /* total length                 */
238         ushort          ip_id;          /* identification               */
239         ushort          ip_off;         /* fragment offset field        */
240         uchar           ip_ttl;         /* time to live                 */
241         uchar           ip_p;           /* protocol                     */
242         ushort          ip_sum;         /* checksum                     */
243         IPaddr_t        ip_src;         /* Source IP address            */
244         IPaddr_t        ip_dst;         /* Destination IP address       */
245         ushort          udp_src;        /* UDP source port              */
246         ushort          udp_dst;        /* UDP destination port         */
247         ushort          udp_len;        /* Length of UDP packet         */
248         ushort          udp_xsum;       /* Checksum                     */
249 };
250
251 #define IP_UDP_HDR_SIZE         (sizeof(struct ip_udp_hdr))
252 #define UDP_HDR_SIZE            (IP_UDP_HDR_SIZE - IP_HDR_SIZE)
253
254 /*
255  *      Address Resolution Protocol (ARP) header.
256  */
257 struct arp_hdr {
258         ushort          ar_hrd;         /* Format of hardware address   */
259 #   define ARP_ETHER        1           /* Ethernet  hardware address   */
260         ushort          ar_pro;         /* Format of protocol address   */
261         uchar           ar_hln;         /* Length of hardware address   */
262 #   define ARP_HLEN     6
263         uchar           ar_pln;         /* Length of protocol address   */
264 #   define ARP_PLEN     4
265         ushort          ar_op;          /* Operation                    */
266 #   define ARPOP_REQUEST    1           /* Request  to resolve  address */
267 #   define ARPOP_REPLY      2           /* Response to previous request */
268
269 #   define RARPOP_REQUEST   3           /* Request  to resolve  address */
270 #   define RARPOP_REPLY     4           /* Response to previous request */
271
272         /*
273          * The remaining fields are variable in size, according to
274          * the sizes above, and are defined as appropriate for
275          * specific hardware/protocol combinations.
276          */
277         uchar           ar_data[0];
278 #define ar_sha          ar_data[0]
279 #define ar_spa          ar_data[ARP_HLEN]
280 #define ar_tha          ar_data[ARP_HLEN + ARP_PLEN]
281 #define ar_tpa          ar_data[ARP_HLEN + ARP_PLEN + ARP_HLEN]
282 #if 0
283         uchar           ar_sha[];       /* Sender hardware address      */
284         uchar           ar_spa[];       /* Sender protocol address      */
285         uchar           ar_tha[];       /* Target hardware address      */
286         uchar           ar_tpa[];       /* Target protocol address      */
287 #endif /* 0 */
288 };
289
290 #define ARP_HDR_SIZE    (8+20)          /* Size assuming ethernet       */
291
292 /*
293  * ICMP stuff (just enough to handle (host) redirect messages)
294  */
295 #define ICMP_ECHO_REPLY         0       /* Echo reply                   */
296 #define ICMP_NOT_REACH          3       /* Detination unreachable       */
297 #define ICMP_REDIRECT           5       /* Redirect (change route)      */
298 #define ICMP_ECHO_REQUEST       8       /* Echo request                 */
299
300 /* Codes for REDIRECT. */
301 #define ICMP_REDIR_NET          0       /* Redirect Net                 */
302 #define ICMP_REDIR_HOST         1       /* Redirect Host                */
303
304 /* Codes for NOT_REACH */
305 #define ICMP_NOT_REACH_PORT     3       /* Port unreachable             */
306
307 struct icmp_hdr {
308         uchar           type;
309         uchar           code;
310         ushort          checksum;
311         union {
312                 struct {
313                         ushort  id;
314                         ushort  sequence;
315                 } echo;
316                 ulong   gateway;
317                 struct {
318                         ushort  __unused;
319                         ushort  mtu;
320                 } frag;
321                 uchar data[0];
322         } un;
323 };
324
325 #define ICMP_HDR_SIZE           (sizeof(struct icmp_hdr))
326 #define IP_ICMP_HDR_SIZE        (IP_HDR_SIZE + ICMP_HDR_SIZE)
327
328 /*
329  * Maximum packet size; used to allocate packet storage.
330  * TFTP packets can be 524 bytes + IP header + ethernet header.
331  * Lets be conservative, and go for 38 * 16.  (Must also be
332  * a multiple of 32 bytes).
333  */
334 /*
335  * AS.HARNOIS : Better to set PKTSIZE to maximum size because
336  * traffic type is not always controlled
337  * maximum packet size =  1518
338  * maximum packet size and multiple of 32 bytes =  1536
339  */
340 #define PKTSIZE                 1518
341 #define PKTSIZE_ALIGN           1536
342 /*#define PKTSIZE               608*/
343
344 /*
345  * Maximum receive ring size; that is, the number of packets
346  * we can buffer before overflow happens. Basically, this just
347  * needs to be enough to prevent a packet being discarded while
348  * we are processing the previous one.
349  */
350 #define RINGSZ          4
351 #define RINGSZ_LOG2     2
352
353 /**********************************************************************/
354 /*
355  *      Globals.
356  *
357  * Note:
358  *
359  * All variables of type IPaddr_t are stored in NETWORK byte order
360  * (big endian).
361  */
362
363 /* net.c */
364 /** BOOTP EXTENTIONS **/
365 extern IPaddr_t NetOurGatewayIP;        /* Our gateway IP address */
366 extern IPaddr_t NetOurSubnetMask;       /* Our subnet mask (0 = unknown) */
367 extern IPaddr_t NetOurDNSIP;    /* Our Domain Name Server (0 = unknown) */
368 #if defined(CONFIG_BOOTP_DNS2)
369 extern IPaddr_t NetOurDNS2IP;   /* Our 2nd Domain Name Server (0 = unknown) */
370 #endif
371 extern char     NetOurNISDomain[32];    /* Our NIS domain */
372 extern char     NetOurHostName[32];     /* Our hostname */
373 extern char     NetOurRootPath[64];     /* Our root path */
374 extern ushort   NetBootFileSize;        /* Our boot file size in blocks */
375 /** END OF BOOTP EXTENTIONS **/
376 extern ulong            NetBootFileXferSize;    /* size of bootfile in bytes */
377 extern uchar            NetOurEther[6];         /* Our ethernet address */
378 extern uchar            NetServerEther[6];      /* Boot server enet address */
379 extern IPaddr_t         NetOurIP;       /* Our    IP addr (0 = unknown) */
380 extern IPaddr_t         NetServerIP;    /* Server IP addr (0 = unknown) */
381 extern uchar            *NetTxPacket;           /* THE transmit packet */
382 extern uchar            *NetRxPackets[PKTBUFSRX]; /* Receive packets */
383 extern uchar            *NetRxPacket;           /* Current receive packet */
384 extern int              NetRxPacketLen;         /* Current rx packet length */
385 extern unsigned         NetIPID;                /* IP ID (counting) */
386 extern uchar            NetBcastAddr[6];        /* Ethernet boardcast address */
387 extern uchar            NetEtherNullAddr[6];
388
389 #define VLAN_NONE       4095                    /* untagged */
390 #define VLAN_IDMASK     0x0fff                  /* mask of valid vlan id */
391 extern ushort           NetOurVLAN;             /* Our VLAN */
392 extern ushort           NetOurNativeVLAN;       /* Our Native VLAN */
393
394 extern int              NetRestartWrap;         /* Tried all network devices */
395
396 enum proto_t {
397         BOOTP, RARP, ARP, TFTPGET, DHCP, PING, DNS, NFS, CDP, NETCONS, SNTP,
398         TFTPSRV, TFTPPUT
399 };
400
401 /* from net/net.c */
402 extern char     BootFile[128];                  /* Boot File name */
403
404 #if defined(CONFIG_CMD_DNS)
405 extern char *NetDNSResolve;             /* The host to resolve  */
406 extern char *NetDNSenvvar;              /* the env var to put the ip into */
407 #endif
408
409 #if defined(CONFIG_CMD_PING)
410 extern IPaddr_t NetPingIP;                      /* the ip address to ping */
411 #endif
412
413 #if defined(CONFIG_CMD_CDP)
414 /* when CDP completes these hold the return values */
415 extern ushort CDPNativeVLAN;            /* CDP returned native VLAN */
416 extern ushort CDPApplianceVLAN;         /* CDP returned appliance VLAN */
417
418 /*
419  * Check for a CDP packet by examining the received MAC address field
420  */
421 static inline int is_cdp_packet(const uchar *et_addr)
422 {
423         extern const uchar NetCDPAddr[6];
424
425         return memcmp(et_addr, NetCDPAddr, 6) == 0;
426 }
427 #endif
428
429 #if defined(CONFIG_CMD_SNTP)
430 extern IPaddr_t NetNtpServerIP;                 /* the ip address to NTP */
431 extern int NetTimeOffset;                       /* offset time from UTC */
432 #endif
433
434 #if defined(CONFIG_MCAST_TFTP)
435 extern IPaddr_t Mcast_addr;
436 #endif
437
438 /* Initialize the network adapter */
439 extern void net_init(void);
440 extern int NetLoop(enum proto_t);
441
442 /* Shutdown adapters and cleanup */
443 extern void     NetStop(void);
444
445 /* Load failed.  Start again. */
446 extern void     NetStartAgain(void);
447
448 /* Get size of the ethernet header when we send */
449 extern int      NetEthHdrSize(void);
450
451 /* Set ethernet header; returns the size of the header */
452 extern int NetSetEther(uchar *, uchar *, uint);
453 extern int net_update_ether(struct ethernet_hdr *et, uchar *addr, uint prot);
454
455 /* Set IP header */
456 extern void net_set_ip_header(uchar *pkt, IPaddr_t dest, IPaddr_t source);
457 extern void net_set_udp_header(uchar *pkt, IPaddr_t dest, int dport,
458                                 int sport, int len);
459
460 /* Checksum */
461 extern int      NetCksumOk(uchar *, int);       /* Return true if cksum OK */
462 extern uint     NetCksum(uchar *, int);         /* Calculate the checksum */
463
464 /* Callbacks */
465 extern rxhand_f *net_get_udp_handler(void);     /* Get UDP RX packet handler */
466 extern void net_set_udp_handler(rxhand_f *);    /* Set UDP RX packet handler */
467 extern rxhand_f *net_get_arp_handler(void);     /* Get ARP RX packet handler */
468 extern void net_set_arp_handler(rxhand_f *);    /* Set ARP RX packet handler */
469 extern void net_set_icmp_handler(rxhand_icmp_f *f); /* Set ICMP RX handler */
470 extern void     NetSetTimeout(ulong, thand_f *);/* Set timeout handler */
471
472 /* Network loop state */
473 enum net_loop_state {
474         NETLOOP_CONTINUE,
475         NETLOOP_RESTART,
476         NETLOOP_SUCCESS,
477         NETLOOP_FAIL
478 };
479 static inline void net_set_state(enum net_loop_state state)
480 {
481         extern enum net_loop_state net_state;
482
483         net_state = state;
484 }
485
486 /* Transmit a packet */
487 static inline void NetSendPacket(uchar *pkt, int len)
488 {
489         (void) eth_send(pkt, len);
490 }
491
492 /*
493  * Transmit "NetTxPacket" as UDP packet, performing ARP request if needed
494  *  (ether will be populated)
495  *
496  * @param ether Raw packet buffer
497  * @param dest IP address to send the datagram to
498  * @param dport Destination UDP port
499  * @param sport Source UDP port
500  * @param payload_len Length of data after the UDP header
501  */
502 extern int NetSendUDPPacket(uchar *ether, IPaddr_t dest, int dport,
503                         int sport, int payload_len);
504
505 /* Processes a received packet */
506 extern void NetReceive(uchar *, int);
507
508 #ifdef CONFIG_NETCONSOLE
509 void NcStart(void);
510 int nc_input_packet(uchar *pkt, unsigned dest, unsigned src, unsigned len);
511 #endif
512
513 /*
514  * Check if autoload is enabled. If so, use either NFS or TFTP to download
515  * the boot file.
516  */
517 void net_auto_load(void);
518
519 /*
520  * The following functions are a bit ugly, but necessary to deal with
521  * alignment restrictions on ARM.
522  *
523  * We're using inline functions, which had the smallest memory
524  * footprint in our tests.
525  */
526 /* return IP *in network byteorder* */
527 static inline IPaddr_t NetReadIP(void *from)
528 {
529         IPaddr_t ip;
530
531         memcpy((void *)&ip, (void *)from, sizeof(ip));
532         return ip;
533 }
534
535 /* return ulong *in network byteorder* */
536 static inline ulong NetReadLong(ulong *from)
537 {
538         ulong l;
539
540         memcpy((void *)&l, (void *)from, sizeof(l));
541         return l;
542 }
543
544 /* write IP *in network byteorder* */
545 static inline void NetWriteIP(void *to, IPaddr_t ip)
546 {
547         memcpy(to, (void *)&ip, sizeof(ip));
548 }
549
550 /* copy IP */
551 static inline void NetCopyIP(void *to, void *from)
552 {
553         memcpy((void *)to, from, sizeof(IPaddr_t));
554 }
555
556 /* copy ulong */
557 static inline void NetCopyLong(ulong *to, ulong *from)
558 {
559         memcpy((void *)to, (void *)from, sizeof(ulong));
560 }
561
562 /**
563  * is_zero_ether_addr - Determine if give Ethernet address is all zeros.
564  * @addr: Pointer to a six-byte array containing the Ethernet address
565  *
566  * Return true if the address is all zeroes.
567  */
568 static inline int is_zero_ether_addr(const u8 *addr)
569 {
570         return !(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]);
571 }
572
573 /**
574  * is_multicast_ether_addr - Determine if the Ethernet address is a multicast.
575  * @addr: Pointer to a six-byte array containing the Ethernet address
576  *
577  * Return true if the address is a multicast address.
578  * By definition the broadcast address is also a multicast address.
579  */
580 static inline int is_multicast_ether_addr(const u8 *addr)
581 {
582         return 0x01 & addr[0];
583 }
584
585 /*
586  * is_broadcast_ether_addr - Determine if the Ethernet address is broadcast
587  * @addr: Pointer to a six-byte array containing the Ethernet address
588  *
589  * Return true if the address is the broadcast address.
590  */
591 static inline int is_broadcast_ether_addr(const u8 *addr)
592 {
593         return (addr[0] & addr[1] & addr[2] & addr[3] & addr[4] & addr[5]) ==
594                 0xff;
595 }
596
597 /*
598  * is_valid_ether_addr - Determine if the given Ethernet address is valid
599  * @addr: Pointer to a six-byte array containing the Ethernet address
600  *
601  * Check that the Ethernet address (MAC) is not 00:00:00:00:00:00, is not
602  * a multicast address, and is not FF:FF:FF:FF:FF:FF.
603  *
604  * Return true if the address is valid.
605  */
606 static inline int is_valid_ether_addr(const u8 *addr)
607 {
608         /* FF:FF:FF:FF:FF:FF is a multicast address so we don't need to
609          * explicitly check for it here. */
610         return !is_multicast_ether_addr(addr) && !is_zero_ether_addr(addr);
611 }
612
613 /* Convert an IP address to a string */
614 extern void ip_to_string(IPaddr_t x, char *s);
615
616 /* Convert a string to ip address */
617 extern IPaddr_t string_to_ip(const char *s);
618
619 /* Convert a VLAN id to a string */
620 extern void VLAN_to_string(ushort x, char *s);
621
622 /* Convert a string to a vlan id */
623 extern ushort string_to_VLAN(const char *s);
624
625 /* read a VLAN id from an environment variable */
626 extern ushort getenv_VLAN(char *);
627
628 /* copy a filename (allow for "..." notation, limit length) */
629 extern void copy_filename(char *dst, const char *src, int size);
630
631 /* get a random source port */
632 extern unsigned int random_port(void);
633
634 /**********************************************************************/
635
636 #endif /* __NET_H__ */