home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 March B / SCO_CASTOR4RRT.iso / nwnet / root / usr / include / sys / nwtdr.h / nwtdr
Text File  |  1998-08-19  |  13KB  |  402 lines
  1. /*
  2.  * Copyright (c) 1998 The Santa Cruz Operation, Inc.. All Rights Reserved. 
  3.  *                                                                         
  4.  *        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF THE               
  5.  *                   SANTA CRUZ OPERATION INC.                             
  6.  *                                                                         
  7.  *   The copyright notice above does not evidence any actual or intended   
  8.  *   publication of such source code.                                      
  9.  */
  10.  
  11. /* $Novell-NWU: $Header: /proj6/ncps/nwu_top/nwnet/include/sys/nwtdr.h,v 1.2 1996/04/05 21:56:13 vtag Exp $ */
  12. /*    Copyright (c) 1990, 1991, 1992, 1993 Novell, Inc. All Rights Reserved.    */
  13. /*    Copyright (c) 1984, 1985, 1986, 1987, 1988, 1989, 1990 Novell, Inc. All Rights Reserved.    */
  14. /*      All Rights Reserved      */
  15.  
  16. /*    THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF Novell Inc.    */
  17. /*    The copyright notice above does not evidence any       */
  18. /*    actual or intended publication of such source code.    */
  19.  
  20. #ifndef _NET_NW_NWTDR_H  /* wrapper symbol for kernel use */
  21. #define _NET_NW_NWTDR_H  /* subject to change without notice */
  22.  
  23. #ident "@(#)nwtdr.h    1.2"
  24.  
  25.  
  26. /*
  27.  * Copyright 1991, 1992 Novell, Inc.
  28.  * All Rights Reserved.
  29.  *
  30.  * This work is subject to U.S. and International copyright laws and
  31.  * treaties.  No part of this work may be used, practiced, performed,
  32.  * copied, distributed, revised, modified, translated, abridged,
  33.  * condensed, expanded, collected, compiled, linked, recast,
  34.  * transformed or adapted without the prior written consent
  35.  * of Novell.  Any use or exploitation of this work without
  36.  * authorization could subject the perpetrator to criminal and
  37.  * civil liability.
  38.  */
  39.  
  40. #ifdef _KERNEL_HEADERS
  41. #include <nwu/nwnet/include/nwportable.h>
  42. #else 
  43. #include <sys/nwportable.h>
  44. #endif /* _KERNEL_HEADERS */
  45.  
  46. /*
  47. **    NetWare/SRC
  48. **
  49. **    Description:
  50. **        NetWare Transparent Data Representation (TDR) macros.
  51. */
  52.  
  53. /*
  54. **    A note on byte ordering
  55. **
  56. **    We differentiate between two types of host byte ordering, that is
  57. **    the way integers are represented in physical memory.  These are:
  58. **
  59. **        - Hi-Lo, also called big endian (M68000, sun4c, rs6000)
  60. **        - Lo-Hi, also called little endian (I386, VAX)
  61. **
  62. **        The numbers (uint32)0x12345678 and (uint16)0x1234 are
  63. **        represented in physical memory as follows:
  64. **
  65. **        Hi-Lo         Address
  66. **                    0        1        2        3
  67. **        uint32        0x12    0x34    0x56    0x78
  68. **        uint16        0x12    0x34
  69. **
  70. **        Lo-Hi        Address
  71. **                    0        1        2        3
  72. **        uint32        0x78    0x56    0x34    0x12
  73. **        uint16        0x34    0x12
  74. **
  75. **    In addition, we need to be aware of network byte ordering.  Network
  76. **    byte ordering is the order that the data is received from the wire or 
  77. **    presented to the wire.  Thus network byte ordering is simply successive
  78. **    characters stored sequentially in memory.  If you always examine the data
  79. **    as an array of characters you will see it in network byte order.  However,
  80. **    to examine integers and interpret them correctly, one must convert them
  81. **    to the correct host byte ordering.  The following macros perform this
  82. **    function and relieve the engineer of the need to know the byte ordering
  83. **    of the host machine.  The macros change the byte ordering only if the host
  84. **    order does not match the network order.  You should note that numbers 
  85. **    can be received over the network in either Hi-Lo or Lo-Hi order.
  86. */
  87.  
  88. /*    Byte ordering macros - changes the byte ordering for integer short and long
  89. **    values
  90. **
  91. **        convert host order -> network order (Integer in Network HI-LO order)
  92. **                        or
  93. **        convert network order (Integer in HI-LO order) -> host order
  94. **
  95. **    Return the changed value
  96. **
  97. **    GETINT16(value)                    Return changed 16 bit value
  98. **    GETINT32(value)                    Return changed 32 bit value
  99. **    PUTINT16(value)                    Same as GETINT16
  100. **    PUTINT32(value)                    Same as GETINT32
  101. **
  102. **    Source or Destination is unaligned pointer
  103. **
  104. **    PGETINT16(src_addr)                Return changed 16 bit value from src_addr
  105. **    PGETINT32(src_addr)                Return changed 32 bit value from src_addr
  106. **    PPUTINT16(value, dest_addr)        Change 16 bit value and save in dest_addr
  107. **    PPUTINT32(value, dest_addr)        Change 32 bit value and save in dest_addr
  108. **
  109. **        convert host order -> network order (Integer in Network LO-HI order)
  110. **                        or
  111. **        convert network order (Integer in LO-HI order) -> host order
  112. **
  113. **    REVGETINT16(value)                Return changed 16 bit value
  114. **    REVGETINT32(value)                Return changed 32 bit value
  115. **    REVPUTINT16(value)                Same as REVGETINT16
  116. **    REVPUTINT32(value)                Same as REVGETINT32
  117. **
  118. **    Source or Destination is unaligned pointer
  119. **
  120. **    PREVGETINT16(src_addr)            Return changed 16 bit value from src_addr
  121. **    PREVGETINT32(src_addr)            Return changed 32 bit value from src_addr
  122. **    PREVPUTINT16(value, dest_addr)    Change 16 bit value and save in dest_addr
  123. **    PREVPUTINT32(value, dest_addr)    Change 32 bit value and save in dest_addr
  124. **
  125. ******************************************************************************
  126. **
  127. **    Alignment macros, copy data where src and/or data address alignment
  128. **        is not guaranteed.  Byte ordering is not changed.
  129. **
  130. **    GETALIGN16(src_addr, dest_addr)     Copy 16 bits from src to dest
  131. **    GETALIGN32(src_addr, dest_addr)     Copy 32 bits from src to dest
  132. **    ALIGNSTRUCT(src_addr, dest_addr) Copy non aligned src struct to dest struct
  133. **
  134. **    Copy a structure, where both sending and receiving struct are assumed
  135. **    to be aligned.
  136. **
  137. **    COPYSTRUCT(src_addr, dest_addr)     Copy src struct to dest struct
  138. */
  139.  
  140. /*
  141. **    Note: if ??????_ALIGNMENT is not defined, define STRICT_ALIGNMENT.
  142. **    Thus, the code will always work since the strict alignment macros
  143. **    will work on all machines (perhaps a little slower).  By doing this,
  144. **    the code will work for user API code, and alignment characteristics
  145. **    need not be defined by API users.
  146. */
  147.  
  148. #if !defined(STRICT_ALIGNMENT) && !defined(PERMISSIVE_ALIGNMENT)
  149. #define STRICT_ALIGNMENT
  150. #endif
  151.  
  152. #ifdef STRICT_ALIGNMENT
  153. /*
  154. **    Return host value from HI-LO at unaligned src_addr
  155. */
  156. #define PGETINT16(src_addr) ( \
  157.     ( (uint16)(((uint8 *)(src_addr))[0]) << 8 ) | \
  158.     ( (uint16)(((uint8 *)(src_addr))[1]) ) \
  159. )
  160. #define PGETINT32(src_addr) ( \
  161.     ( (uint32)(((uint8 *)(src_addr))[0]) << 24 ) | \
  162.     ( (uint32)(((uint8 *)(src_addr))[1]) << 16 ) | \
  163.     ( (uint32)(((uint8 *)(src_addr))[2]) << 8 ) | \
  164.     ( (uint32)(((uint8 *)(src_addr))[3]) ) \
  165. )
  166. /*
  167. **    Return host value from LO_HI at unaligned src_addr
  168. */
  169. #define PREVGETINT16(src_addr) ( \
  170.     ( (uint16)(((uint8 *)(src_addr))[1]) << 8 ) | \
  171.     ( (uint16)(((uint8 *)(src_addr))[0]) ) \
  172. )
  173. #define PREVGETINT32(src_addr) ( \
  174.     ( (uint32)(((uint8 *)(src_addr))[3]) << 24 ) | \
  175.     ( (uint32)(((uint8 *)(src_addr))[2]) << 16 ) | \
  176.     ( (uint32)(((uint8 *)(src_addr))[1]) << 8 ) | \
  177.     ( (uint32)(((uint8 *)(src_addr))[0]) ) \
  178. )
  179. #endif
  180.  
  181. #ifdef PERMISSIVE_ALIGNMENT
  182. /*
  183. **    Return host value from HI_LO src_addr
  184. */
  185. #define PGETINT16(src_addr) ( GETINT16( *((uint16 *)(src_addr))))
  186. #define PGETINT32(src_addr) ( GETINT32( *((uint32 *)(src_addr))))
  187. /*
  188. **    Return host value from LO_HI at unaligned src_addr
  189. */
  190. #define PREVGETINT16(src_addr) ( REVGETINT16( *((uint16 *)(src_addr))))
  191. #define PREVGETINT32(src_addr) ( REVGETINT32( *((uint32 *)(src_addr))))
  192. #endif
  193.  
  194. #ifdef STRICT_ALIGNMENT
  195. /*
  196. ** Copy host value and change to HI-LO byte order at unaligned dest_addr
  197. */
  198. #define PPUTINT16(value, dest_addr) ( \
  199.     (((uint8 *)(dest_addr))[0] = (uint8)((uint16)(value)>>8)), \
  200.     (((uint8 *)(dest_addr))[1] = (uint8)(value)) \
  201. )
  202. #define PPUTINT32(value, dest_addr) ( \
  203.     (((uint8 *)(dest_addr))[0] = (uint8)((uint32)(value)>>24)), \
  204.     (((uint8 *)(dest_addr))[1] = (uint8)((uint32)(value)>>16)), \
  205.     (((uint8 *)(dest_addr))[2] = (uint8)((uint32)(value)>>8)), \
  206.     (((uint8 *)(dest_addr))[3] = (uint8)(value)) \
  207. )
  208. /*
  209. ** Copy host value and change to LO_HI byte order at unaligned dest_addr
  210. */
  211. #define PREVPUTINT16(value, dest_addr) ( \
  212.     (((uint8 *)(dest_addr))[1] = (uint8)((uint16)(value)>>8)), \
  213.     (((uint8 *)(dest_addr))[0] = (uint8)(value)) \
  214. )
  215. #define PREVPUTINT32(value, dest_addr) ( \
  216.     (((uint8 *)(dest_addr))[3] = (uint8)((uint32)(value)>>24)), \
  217.     (((uint8 *)(dest_addr))[2] = (uint8)((uint32)(value)>>16)), \
  218.     (((uint8 *)(dest_addr))[1] = (uint8)((uint32)(value)>>8)), \
  219.     (((uint8 *)(dest_addr))[0] = (uint8)(value)) \
  220. )
  221. #endif
  222.  
  223. #ifdef PERMISSIVE_ALIGNMENT
  224. /*
  225. ** Copy host value and change to HI-LO byte order at unaligned dest_addr
  226. */
  227. #define PPUTINT16(value, dest_addr) ( *(uint16 *)(dest_addr) = PUTINT16( (uint16)(value)))
  228. #define PPUTINT32(value, dest_addr) ( *(uint32 *)(dest_addr) = PUTINT32( (uint32)(value)))
  229. /*
  230. ** Copy host value and change to LO_HI byte order at unaligned dest_addr
  231. */
  232. #define PREVPUTINT16(value, dest_addr) ( *(uint16 *)(dest_addr) = REVPUTINT16( (uint16)(value)))
  233. #define PREVPUTINT32(value, dest_addr) ( *(uint32 *)(dest_addr) = REVPUTINT32( (uint32)(value)))
  234. #endif
  235.  
  236. #ifdef LO_HI_MACH_TYPE     
  237. /*
  238. **    Return host value from HI-LO value
  239. */
  240. #define GETINT16(x)        (uint16)(\
  241.                         ((uint16)((x) & 0x00FF) << 8) | \
  242.                         ((uint16)((x) & 0xFF00) >> 8) \
  243.                         )
  244. #define PUTINT16(x)        GETINT16(x)
  245.  
  246. #define GETINT32(x)        (uint32)(\
  247.                         ((uint32)((x) & 0x000000FF) << 24) | \
  248.                         ((uint32)((x) & 0x0000FF00) <<  8) | \
  249.                         ((uint32)((x) & 0x00FF0000) >>  8) | \
  250.                         ((uint32)((x) & 0xFF000000) >> 24) \
  251.                         ) 
  252. #define PUTINT32(x)        GETINT32(x)
  253. /*
  254. **    Return host value from LO_HI value
  255. */
  256. #define REVGETINT16(x)        (x)
  257. #define REVPUTINT16(x)        (x)
  258. #define REVGETINT32(x)        (x)
  259. #define REVPUTINT32(x)        (x)
  260. #endif   /*  end of #ifdef LO_HI */
  261.  
  262. #ifdef HI_LO_MACH_TYPE
  263. /*
  264. **    Return host value from HI-LO value
  265. */
  266. #define GETINT16(x)            (x)
  267. #define GETINT32(x)            (x)
  268. #define PUTINT16(x)            (x)
  269. #define PUTINT32(x)            (x)
  270. /*
  271. **    Return host value from LO_HI value
  272. */
  273. #define    REVGETINT16(x)        (\
  274.                             ((uint16)((x) & 0x00FF) << 8) | \
  275.                             ((uint16)((x) & 0xFF00) >> 8) \
  276.                             )
  277. #define REVPUTINT16(x)        REVGETINT16(x)
  278. #define REVGETINT32(x)        (\
  279.                             ((uint32)((x) & 0x000000FF) << 24) | \
  280.                             ((uint32)((x) & 0x0000FF00) <<  8) | \
  281.                             ((uint32)((x) & 0x00FF0000) >>  8) | \
  282.                             ((uint32)((x) & 0xFF000000) >> 24) \
  283.                             ) 
  284. #define REVPUTINT32(x)        REVGETINT32(x)
  285. #endif   /*  end of #ifdef HI_LO_MACH_TYPE */
  286.  
  287. #if !defined(LO_HI_MACH_TYPE) && !defined(HI_LO_MACH_TYPE)
  288.  
  289. /*
  290. **    For API users who probably don't know about setting LO_HI or HI_LO
  291. **    defines, we want to do the right thing without forcing on them a
  292. **    knowledge of the host byte ordering.  The following have the added
  293. **    overhead of a function call.
  294. */
  295.  
  296. /*
  297. **    Return host value from HI-LO value
  298. */
  299. #define GETINT16(num) getint16(num)
  300. #define PUTINT16(num) getint16(num)
  301. static uint16 getint16(uint16 num)
  302. {
  303.     return(
  304.     ( ((uint8 *)(&(num)))[0] << 8 ) |
  305.     ( ((uint8 *)(&(num)))[1] ));
  306. }
  307.  
  308. #define GETINT32(num) getint32(num)
  309. #define PUTINT32(num) getint32(num)
  310. static uint32 getint32(uint32 num)
  311. {
  312.     return(
  313.     ( ((uint8 *)(&(num)))[0] << 24 ) | 
  314.     ( ((uint8 *)(&(num)))[1] << 16 ) |
  315.     ( ((uint8 *)(&(num)))[2] << 8 ) |
  316.     ( ((uint8 *)(&(num)))[3] ));
  317. }
  318.  
  319. /*
  320. **    Return host value from LO_HI value
  321. */
  322. #define REVGETINT16(num) revgetint16(num)
  323. #define REVPUTINT16(num) revgetint16(num)
  324. static uint16 revgetint16(uint16 num)
  325. {
  326.     return( 
  327.         ( ((uint8 *)(&(num)))[0]) |
  328.         ( ((uint8 *)(&(num)))[1] << 8 ));
  329. }
  330.  
  331. #define REVGETINT32(num) revgetint32(num)
  332. #define REVPUTINT32(num) revgetint32(num)
  333. static uint32 revgetint32(uint32 num)
  334. {
  335.     return(
  336.     ( ((uint8 *)(&(num)))[0]) | 
  337.     ( ((uint8 *)(&(num)))[1] << 8) |
  338.     ( ((uint8 *)(&(num)))[2] << 16) |
  339.     ( ((uint8 *)(&(num)))[3] << 24));
  340. }
  341. #endif /* Neither LO_HI nor HI_LO */
  342.  
  343.  
  344. /*
  345. **    Copy unaligned source structure to destination structure (of same type)
  346. **    Uses compiler generated structure assignment if possible.
  347. */
  348. #ifdef PERMISSIVE_ALIGNMENT
  349. #define ALIGNSTRUCT(src_addr, dest_addr, len)    *(dest_addr) = *(src_addr)
  350. #endif
  351.  
  352. #ifdef STRICT_ALIGNMENT
  353. #ifdef _KERNEL
  354. #define ALIGNSTRUCT(src_addr, dest_addr, len)    bcopy(src_addr, dest_addr, len)
  355. #else
  356. #define ALIGNSTRUCT(src_addr, dest_addr, len)    memcpy(dest_addr, src_addr, len)
  357. #endif 
  358. #endif /* STRICT_ALIGNMENT */
  359.  
  360. /*
  361. **    Copy source structure to destination structure (of same type).
  362. **    Both structures must be aligned. Uses compiler structure assignment.
  363. */
  364. #define COPYSTRUCT(src_addr, dest_addr, len)    *(dest_addr) = *(src_addr)
  365.  
  366. /*
  367. **    GETALIGN macros are defined on STRICT_ALIGNMENT machines
  368. **    to reference the variables as character arrays.  This forces
  369. **    the compiler to copy them by character, thus avoiding any
  370. **    alignment problems when doing structure assignment.
  371. */
  372. #ifdef PERMISSIVE_ALIGNMENT
  373. #define GETALIGN16(s,d)    (*((uint16 *)(d)) = *((uint16 *)(s)))
  374. #define GETALIGN32(s,d)    (*((uint32 *)(d)) = *((uint32 *)(s)))
  375. #endif
  376.  
  377. #ifdef STRICT_ALIGNMENT
  378. typedef struct { uint8 l[4]; } _cp_long_t;
  379. typedef struct { uint8 s[2]; } _cp_short_t;
  380. #define    GETALIGN16(s,d)    (*((_cp_short_t *)(d)) = *((_cp_short_t *)(s)))
  381. #define    GETALIGN32(s,d)    (*((_cp_long_t *)(d)) = *((_cp_long_t *)(s)))
  382. #endif        /* end of STRICT_ALIGN */
  383.  
  384. /*
  385.  * The following obtain the Hi long or Low long of a quad value
  386.  * and are used in the xfs file system. File nxfsuser.h will
  387.  * need to be included to use the macros.  The actual "quad" structure
  388.  * is defined in file /usr/include/sys/types.h.
  389.  */
  390. #ifdef HI_LO_MACH_TYPE
  391. #define GETQUADLOW(s) ((s).val[1])
  392. #define GETQUADHI(s) ((s).val[0])
  393. #endif
  394. #ifdef LO_HI_MACH_TYPE
  395. #define GETQUADLOW(s) ((s).val[0])
  396. #define GETQUADHI(s) ((s).val[1])
  397. #endif
  398. #define PUTQUADLOW(s) GETQUADLOW(s) 
  399. #define PUTQUADHI(s) GETQUADHI(s) 
  400.  
  401. #endif /* _NET_NW_NWTDR_H */
  402.