venti-packet man page on Plan9

Man page or keyword search:  
man Server   549 pages
apropos Keyword Search (all sections)
Output format
Plan9 logo
[printable version]


       Packet,	packetalloc,  packetappend, packetasize, packetcmp, packetcon‐
       cat, packetconsume, packetcopy, packetdup,  packetforeign,  packetfrag‐
       ments,  packetfree, packetheader, packetpeek, packetprefix, packetsha1,
       packetsize, packetsplit, packetstats, packettrailer, packettrim - zero-
       copy network buffers

       #include <u.h>
       #include <libc.h>
       #include <venti.h>

       Packet* packetalloc(void);

       void    packetappend(Packet *p, uchar *buf, int n)

       uint    packetasize(Packet *p)

       int     packetcmp(Packet *p, Packet *q)

       void    packetconcat(Packet *p, Packet *q)

       int     packetconsume(Packet *p, uchar *buf, int n)

       int     packetcopy(Packet *p, uchar *buf, int offset, int n)

       Packet* packetdup(Packet *p, int offset, int n)

       Packet* packetforeign(uchar *buf, int n,
		   void (*free)(void *a), void *a)

       int     packetfragments(Packet *p, IOchunk *io, int nio,
		   int offset)

       void    packetfree(Packet *p)

       uchar*  packetheader(Packet *p, int n)

       uchar*  packetpeek(Packet *p, uchar *buf, int offset, int n)

       void    packetprefix(Packet *p, uchar *buf, int n)

       void    packetsha1(Packet *p, uchar sha1[20])

       uint    packetsize(Packet *p)

       Packet* packetsplit(Packet *p, int n)

       void    packetstats(void)

       uchar*  packettrailer(Packet *p, int n)

       int     packettrim(Packet *p, int offset, int n)

       A  Packet is a chain of blocks of data.	Each block, called a fragment,
       is contiguous in memory, but the entire packet may not be.  This repre‐
       sentation helps avoid unnecessary memory copies.

       Packetalloc allocates an empty packet.

       Packetappend appends the n bytes at buf to the end of p.

       Packetasize  returns the number of data bytes allocated to p.  This may
       be larger than the number of bytes stored in p  because	fragments  may
       not be filled completely.

       Packetcmp compares the data sections of two packets as memcmp (see mem‐
       ory(2)) would.

       Packetconcat removes all data from q, appending it to p.

       Packetconsume removes n bytes from the beginning	 of  p,	 storing  them
       into buf.

       Packetcopy copies n bytes at offset in p to buf.

       Packetdup  creates a new packet initialized with n bytes from offset in

       Packetforeign allocates a packet containing `foreign' data: the n bytes
       pointed to by buf.  Once the bytes are no longer needed, they are freed
       by calling free(a).

       Packetfragments initializes up to nio of the io structures with	point‐
       ers  to the data in p, starting at offset.  It returns the total number
       of bytes represented by the returned structures.	 Packetfragments  ini‐
       tializes any unused io structures with nil pointer and zero length.

       Packetfree frees the packet p.

       Packetheader  returns  a pointer to the first n bytes of p, making them
       contiguous in memory if necessary.

       Packetpeek returns a pointer to the n bytes at offset  in  p.   If  the
       requested bytes are already stored contiguously in memory, the returned
       pointer points at the internal data  storage  for  p.   Otherwise,  the
       bytes are copied into buf, and packetpeek returns buf.

       Packetprefix  inserts  a copy of the n bytes at buf at the beginning of

       Packetsha1 computes the SHA1 hash of the data contained in p.

       Packetsize returns the length, in bytes, of the data contained in p.

       Packetsplit returns a new packet initialized with n bytes removed  from
       the beginning of p.

       Packetstats prints run-time statistics to standard output.

       Packettrailer  returns  a pointer to the last n bytes of p, making them
       contiguous in memory if necessary.

       Packettrim deletes all bytes from the packet p except the  n  bytes  at
       offset offset.



       These  functions	 return	 errors only when passed invalid inputs, e.g.,
       requests for data at negative offsets or beyond the end of a packet.

       Functions returning pointers return nil on error;  functions  returning
       integers	 return -1 on error.  Most functions returning integers return
       0 on success.  The exceptions are packetfragments and packetcmp,	 whose
       return values are described above.

       When  these  functions run out of memory, they print error messages and
       call sysfatal.

                             _         _         _ 
                            | |       | |       | |     
                            | |       | |       | |     
                         __ | | __ __ | | __ __ | | __  
                         \ \| |/ / \ \| |/ / \ \| |/ /  
                          \ \ / /   \ \ / /   \ \ / /   
                           \   /     \   /     \   /    
                            \_/       \_/       \_/ 
More information is available in HTML format for server Plan9

List of man pages available for Plan9

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net