home *** CD-ROM | disk | FTP | other *** search
/ Big Green CD 8 / BGCD_8_Dev.iso / NEXTSTEP / Networking / SambaManager / byteorder.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-03-10  |  9.6 KB  |  247 lines
  1. /* 
  2.    Unix SMB/Netbios implementation.
  3.    Version 1.9.
  4.    SMB Byte handling
  5.    Copyright (C) Andrew Tridgell 1992-1997
  6.    
  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 2 of the License, or
  10.    (at your option) any later version.
  11.    
  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.
  16.    
  17.    You should have received a copy of the GNU General Public License
  18.    along with this program; if not, write to the Free Software
  19.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20.      
  21.      This was stolen and modified from the samba distribution.
  22.      You will most probably already have samba if you are using this software.
  23. */
  24.  
  25. /*
  26.    This file implements macros for machine independent short and 
  27.    int manipulation
  28.  
  29. Here is a description of this file that I emailed to the samba list once:
  30.  
  31. > I am confused about the way that byteorder.h works in Samba. I have
  32. > looked at it, and I would have thought that you might make a distinction
  33. > between LE and BE machines, but you only seem to distinguish between 386
  34. > and all other architectures.
  35. > 
  36. > Can you give me a clue?
  37.  
  38. sure.
  39.  
  40. The distinction between 386 and other architectures is only there as
  41. an optimisation. You can take it out completely and it will make no
  42. difference. The routines (macros) in byteorder.h are totally byteorder
  43. independent. The 386 optimsation just takes advantage of the fact that
  44. the x86 processors don't care about alignment, so we don't have to
  45. align ints on int boundaries etc. If there are other processors out
  46. there that aren't alignment sensitive then you could also define
  47. CAREFUL_ALIGNMENT=0 on those processors as well.
  48.  
  49. Ok, now to the macros themselves. I'll take a simple example, say we
  50. want to extract a 2 byte integer from a SMB packet and put it into a
  51. type called uint16 that is in the local machines byte order, and you
  52. want to do it with only the assumption that uint16 is _at_least_ 16
  53. bits long (this last condition is very important for architectures
  54. that don't have any int types that are 2 bytes long)
  55.  
  56. You do this:
  57.  
  58. #define CVAL(buf,pos) (((unsigned char *)(buf))[pos])
  59. #define PVAL(buf,pos) ((unsigned)CVAL(buf,pos))
  60. #define SVAL(buf,pos) (PVAL(buf,pos)|PVAL(buf,(pos)+1)<<8)
  61.  
  62. then to extract a uint16 value at offset 25 in a buffer you do this:
  63.  
  64. char *buffer = foo_bar();
  65. uint16 xx = SVAL(buffer,25);
  66.  
  67. We are using the byteoder independence of the ANSI C bitshifts to do
  68. the work. A good optimising compiler should turn this into efficient
  69. code, especially if it happens to have the right byteorder :-)
  70.  
  71. I know these macros can be made a bit tidier by removing some of the
  72. casts, but you need to look at byteorder.h as a whole to see the
  73. reasoning behind them. byteorder.h defines the following macros:
  74.  
  75. SVAL(buf,pos) - extract a 2 byte SMB value
  76. IVAL(buf,pos) - extract a 4 byte SMB value
  77. SVALS(buf,pos) signed version of SVAL()
  78. IVALS(buf,pos) signed version of IVAL()
  79.  
  80. SSVAL(buf,pos,val) - put a 2 byte SMB value into a buffer
  81. SIVAL(buf,pos,val) - put a 4 byte SMB value into a buffer
  82. SSVALS(buf,pos,val) - signed version of SSVAL()
  83. SIVALS(buf,pos,val) - signed version of SIVAL()
  84.  
  85. RSVAL(buf,pos) - like SVAL() but for NMB byte ordering
  86. RIVAL(buf,pos) - like IVAL() but for NMB byte ordering
  87. RSSVAL(buf,pos,val) - like SSVAL() but for NMB ordering
  88. RSIVAL(buf,pos,val) - like SIVAL() but for NMB ordering
  89.  
  90. it also defines lots of intermediate macros, just ignore those :-)
  91.  
  92. */
  93.  
  94. /* some switch macros that do both store and read to and from SMB buffers */
  95.  
  96. #define RW_PCVAL(read,inbuf,outbuf,len) \
  97.                 if (read) { PCVAL (inbuf,0,outbuf,len) } \
  98.                 else      { PSCVAL(inbuf,0,outbuf,len) }
  99.  
  100. #define RW_PIVAL(read,inbuf,outbuf,len) \
  101.                 if (read) { PIVAL (inbuf,0,outbuf,len) } \
  102.                 else      { PSIVAL(inbuf,0,outbuf,len) }
  103.  
  104. #define RW_PSVAL(read,inbuf,outbuf,len) \
  105.                 if (read) { PSVAL (inbuf,0,outbuf,len) } \
  106.                 else      { PSSVAL(inbuf,0,outbuf,len) }
  107.  
  108. #define RW_CVAL(read, inbuf, outbuf, offset) \
  109.                 if (read) (outbuf) = CVAL (inbuf,offset); \
  110.                 else                 SCVAL(inbuf,offset,outbuf);
  111.  
  112. #define RW_IVAL(read, inbuf, outbuf, offset) \
  113.                 if (read) (outbuf)= IVAL (inbuf,offset); \
  114.                 else                SIVAL(inbuf,offset,outbuf);
  115.  
  116. #define RW_SVAL(read, inbuf, outbuf, offset) \
  117.                 if (read) (outbuf)= SVAL (inbuf,offset); \
  118.                 else                SSVAL(inbuf,offset,outbuf);
  119.  
  120. #undef CAREFUL_ALIGNMENT
  121.  
  122. /* we know that the 386 can handle misalignment and has the "right" 
  123.    byteorder */
  124. #ifdef __i386__
  125. #define CAREFUL_ALIGNMENT 0
  126. #endif
  127.  
  128. #ifndef CAREFUL_ALIGNMENT
  129. #define CAREFUL_ALIGNMENT 1
  130. #endif
  131.  
  132. #define CVAL(buf,pos) (((unsigned char *)(buf))[pos])
  133. #define PVAL(buf,pos) ((unsigned)CVAL(buf,pos))
  134. #define SCVAL(buf,pos,val) (CVAL(buf,pos) = (val))
  135.  
  136.  
  137. #if CAREFUL_ALIGNMENT
  138.  
  139. #define SVAL(buf,pos) (PVAL(buf,pos)|PVAL(buf,(pos)+1)<<8)
  140. #define IVAL(buf,pos) (SVAL(buf,pos)|SVAL(buf,(pos)+2)<<16)
  141. #define SSVALX(buf,pos,val) (CVAL(buf,pos)=(val)&0xFF,CVAL(buf,pos+1)=(val)>>8)
  142. #define SIVALX(buf,pos,val) (SSVALX(buf,pos,val&0xFFFF),SSVALX(buf,pos+2,val>>16))
  143. #define SVALS(buf,pos) ((int16)SVAL(buf,pos))
  144. #define IVALS(buf,pos) ((int32)IVAL(buf,pos))
  145. #define SSVAL(buf,pos,val) SSVALX((buf),(pos),((uint16)(val)))
  146. #define SIVAL(buf,pos,val) SIVALX((buf),(pos),((uint32)(val)))
  147. #define SSVALS(buf,pos,val) SSVALX((buf),(pos),((int16)(val)))
  148. #define SIVALS(buf,pos,val) SIVALX((buf),(pos),((int32)(val)))
  149.  
  150. #else
  151.  
  152. /* this handles things for architectures like the 386 that can handle
  153.    alignment errors */
  154. /*
  155.    WARNING: This section is dependent on the length of int16 and int32
  156.    being correct 
  157. */
  158.  
  159. /* get single value from an SMB buffer */
  160. #define SVAL(buf,pos) (*(uint16 *)((char *)(buf) + (pos)))
  161. #define IVAL(buf,pos) (*(uint32 *)((char *)(buf) + (pos)))
  162. #define SVALS(buf,pos) (*(int16 *)((char *)(buf) + (pos)))
  163. #define IVALS(buf,pos) (*(int32 *)((char *)(buf) + (pos)))
  164.  
  165. /* store single value in an SMB buffer */
  166. #define SSVAL(buf,pos,val) SVAL(buf,pos)=((uint16)(val))
  167. #define SIVAL(buf,pos,val) IVAL(buf,pos)=((uint32)(val))
  168. #define SSVALS(buf,pos,val) SVALS(buf,pos)=((int16)(val))
  169. #define SIVALS(buf,pos,val) IVALS(buf,pos)=((int32)(val))
  170.  
  171. #endif
  172.  
  173.  
  174. /* macros for reading / writing arrays */
  175.  
  176. #define SMBMACRO(macro,buf,pos,val,len,size) \
  177. { int l; for (l = 0; l < (len); l++) (val)[l] = macro((buf), (pos) + (size)*l); }
  178.  
  179. #define SSMBMACRO(macro,buf,pos,val,len,size) \
  180. { int l; for (l = 0; l < (len); l++) macro((buf), (pos) + (size)*l, (val)[l]); }
  181.  
  182. /* reads multiple data from an SMB buffer */
  183. #define PCVAL(buf,pos,val,len) SMBMACRO(CVAL,buf,pos,val,len,1)
  184. #define PSVAL(buf,pos,val,len) SMBMACRO(SVAL,buf,pos,val,len,2)
  185. #define PIVAL(buf,pos,val,len) SMBMACRO(IVAL,buf,pos,val,len,4)
  186. #define PCVALS(buf,pos,val,len) SMBMACRO(CVALS,buf,pos,val,len,1)
  187. #define PSVALS(buf,pos,val,len) SMBMACRO(SVALS,buf,pos,val,len,2)
  188. #define PIVALS(buf,pos,val,len) SMBMACRO(IVALS,buf,pos,val,len,4)
  189.  
  190. /* stores multiple data in an SMB buffer */
  191. #define PSCVAL(buf,pos,val,len) SSMBMACRO(SCVAL,buf,pos,val,len,1)
  192. #define PSSVAL(buf,pos,val,len) SSMBMACRO(SSVAL,buf,pos,val,len,2)
  193. #define PSIVAL(buf,pos,val,len) SSMBMACRO(SIVAL,buf,pos,val,len,4)
  194. #define PSCVALS(buf,pos,val,len) SSMBMACRO(SCVALS,buf,pos,val,len,1)
  195. #define PSSVALS(buf,pos,val,len) SSMBMACRO(SSVALS,buf,pos,val,len,2)
  196. #define PSIVALS(buf,pos,val,len) SSMBMACRO(SIVALS,buf,pos,val,len,4)
  197.  
  198.  
  199. /* now the reverse routines - these are used in nmb packets (mostly) */
  200. #define SREV(x) ((((x)&0xFF)<<8) | (((x)>>8)&0xFF))
  201. #define IREV(x) ((SREV(x)<<16) | (SREV((x)>>16)))
  202.  
  203. #define RSVAL(buf,pos) SREV(SVAL(buf,pos))
  204. #define RIVAL(buf,pos) IREV(IVAL(buf,pos))
  205. #define RSSVAL(buf,pos,val) SSVAL(buf,pos,SREV(val))
  206. #define RSIVAL(buf,pos,val) SIVAL(buf,pos,IREV(val))
  207.  
  208. #define DBG_RW_PCVAL(charmode,string,depth,base,read,inbuf,outbuf,len) \
  209.     RW_PCVAL(read,inbuf,outbuf,len) \
  210.     DEBUG(5,("%s%04x %s: ", \
  211.              tab_depth(depth), PTR_DIFF(inbuf,base),string)); \
  212.     if (charmode) print_asc(5, (unsigned char*)(outbuf), (len)); else \
  213.     { int idx; for (idx = 0; idx < len; idx++) { DEBUG(5,("%02x ", (outbuf)[idx])); } } \
  214.     DEBUG(5,("\n"));
  215.  
  216. #define DBG_RW_PSVAL(charmode,string,depth,base,read,inbuf,outbuf,len) \
  217.     RW_PSVAL(read,inbuf,outbuf,len) \
  218.     DEBUG(5,("%s%04x %s: ", \
  219.              tab_depth(depth), PTR_DIFF(inbuf,base),string)); \
  220.     if (charmode) print_asc(5, (unsigned char*)(outbuf), 2*(len)); else \
  221.     { int idx; for (idx = 0; idx < len; idx++) { DEBUG(5,("%04x ", (outbuf)[idx])); } } \
  222.     DEBUG(5,("\n"));
  223.  
  224. #define DBG_RW_PIVAL(charmode,string,depth,base,read,inbuf,outbuf,len) \
  225.     RW_PIVAL(read,inbuf,outbuf,len) \
  226.     DEBUG(5,("%s%04x %s: ", \
  227.              tab_depth(depth), PTR_DIFF(inbuf,base),string)); \
  228.     if (charmode) print_asc(5, (unsigned char*)(outbuf), 4*(len)); else \
  229.     { int idx; for (idx = 0; idx < len; idx++) { DEBUG(5,("%08x ", (outbuf)[idx])); } } \
  230.     DEBUG(5,("\n"));
  231.  
  232. #define DBG_RW_CVAL(string,depth,base,read,inbuf,outbuf) \
  233.     RW_CVAL(read,inbuf,outbuf,0) \
  234.     DEBUG(5,("%s%04x %s: %02x\n", \
  235.              tab_depth(depth), PTR_DIFF(inbuf,base), string, outbuf));
  236.  
  237. #define DBG_RW_SVAL(string,depth,base,read,inbuf,outbuf) \
  238.     RW_SVAL(read,inbuf,outbuf,0) \
  239.     DEBUG(5,("%s%04x %s: %04x\n", \
  240.              tab_depth(depth), PTR_DIFF(inbuf,base), string, outbuf));
  241.  
  242. #define DBG_RW_IVAL(string,depth,base,read,inbuf,outbuf) \
  243.     RW_IVAL(read,inbuf,outbuf,0) \
  244.     DEBUG(5,("%s%04x %s: %08x\n", \
  245.              tab_depth(depth), PTR_DIFF(inbuf,base), string, outbuf));
  246.  
  247.