/src/jcifs/netbios/NameServicePacket.java

https://github.com/drheydenreich/jcifs · Java · 337 lines · 289 code · 27 blank · 21 comment · 15 complexity · 5150ba94372aed83aa6794054ec9f4e1 MD5 · raw file 

    

  1. /* jcifs smb client library in Java

    2. 

  2.  * Copyright (C) 2000  "Michael B. Allen" <jcifs at samba dot org>

    3. 

  3.  * 

    4. 

  4.  * This library is free software; you can redistribute it and/or

    5. 

  5.  * modify it under the terms of the GNU Lesser General Public

    6. 

  6.  * License as published by the Free Software Foundation; either

    7. 

  7.  * version 2.1 of the License, or (at your option) any later version.

    8. 

  8.  * 

    9. 

  9.  * This library is distributed in the hope that it will be useful,

    10. 

  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11. 

  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    12. 

  12.  * Lesser General Public License for more details.

    13. 

  13.  * 

    14. 

  14.  * You should have received a copy of the GNU Lesser General Public

    15. 

  15.  * License along with this library; if not, write to the Free Software

    16. 

  16.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    17. 

  17.  */

    18. 

  18. 

    19. 

  19. package jcifs.netbios;

    20. 

  20. 

    21. 

  21. import java.net.InetAddress;

    22. 

  22. import jcifs.util.Hexdump;

    23. 

  23. 

    24. 

  24. abstract class NameServicePacket {

    25. 

  25. 

    26. 

  26.     // opcode

    27. 

  27.     static final int QUERY = 0;

    28. 

  28.     static final int WACK = 7;

    29. 

  29. 

    30. 

  30.     // rcode

    31. 

  31.     static final int FMT_ERR = 0x1;

    32. 

  32.     static final int SRV_ERR = 0x2;

    33. 

  33.     static final int IMP_ERR = 0x4;

    34. 

  34.     static final int RFS_ERR = 0x5;

    35. 

  35.     static final int ACT_ERR = 0x6;

    36. 

  36.     static final int CFT_ERR = 0x7;

    37. 

  37. 

    38. 

  38.     // type/class

    39. 

  39.     static final int NB_IN     = 0x00200001;

    40. 

  40.     static final int NBSTAT_IN = 0x00210001;

    41. 

  41.     static final int NB        = 0x0020;

    42. 

  42.     static final int NBSTAT    = 0x0021;

    43. 

  43.     static final int IN        = 0x0001;

    44. 

  44.     static final int A         = 0x0001;

    45. 

  45.     static final int NS        = 0x0002;

    46. 

  46.     static final int NULL      = 0x000a;

    47. 

  47. 

    48. 

  48.     static final int HEADER_LENGTH = 12;

    49. 

  49. 

    50. 

  50.     // header field offsets

    51. 

  51.     static final int OPCODE_OFFSET = 2;

    52. 

  52.     static final int QUESTION_OFFSET = 4;

    53. 

  53.     static final int ANSWER_OFFSET = 6;

    54. 

  54.     static final int AUTHORITY_OFFSET = 8;

    55. 

  55.     static final int ADDITIONAL_OFFSET = 10;

    56. 

  56. 

    57. 

  57.     static void writeInt2( int val, byte[] dst, int dstIndex ) {

    58. 

  58.         dst[dstIndex++] = (byte)(( val >> 8 ) & 0xFF );

    59. 

  59.         dst[dstIndex] = (byte)( val & 0xFF );

    60. 

  60.     }

    61. 

  61.     static void writeInt4( int val, byte[] dst, int dstIndex ) {

    62. 

  62.         dst[dstIndex++] = (byte)(( val >> 24 ) & 0xFF );

    63. 

  63.         dst[dstIndex++] = (byte)(( val >> 16 ) & 0xFF );

    64. 

  64.         dst[dstIndex++] = (byte)(( val >> 8 ) & 0xFF );

    65. 

  65.         dst[dstIndex] = (byte)( val & 0xFF );

    66. 

  66.     }

    67. 

  67.     static int readInt2( byte[] src, int srcIndex ) {

    68. 

  68.         return (( src[srcIndex] & 0xFF ) << 8 ) +

    69. 

  69.                 ( src[srcIndex + 1] & 0xFF );

    70. 

  70.     }

    71. 

  71.     static int readInt4( byte[] src, int srcIndex ) {

    72. 

  72.         return (( src[srcIndex] & 0xFF ) << 24 ) +

    73. 

  73.                 (( src[srcIndex + 1] & 0xFF ) << 16 ) +

    74. 

  74.                 (( src[srcIndex + 2] & 0xFF ) << 8 ) +

    75. 

  75.                 ( src[srcIndex + 3] & 0xFF );

    76. 

  76.     }

    77. 

  77. 

    78. 

  78.     static int readNameTrnId( byte[] src, int srcIndex ) {

    79. 

  79.         return readInt2( src, srcIndex );

    80. 

  80.     }

    81. 

  81. 

    82. 

  82.     int addrIndex;

    83. 

  83.     NbtAddress[] addrEntry;

    84. 

  84. 

    85. 

  85.     int nameTrnId;

    86. 

  86. 

    87. 

  87.     int opCode,

    88. 

  88.             resultCode,

    89. 

  89.             questionCount,

    90. 

  90.             answerCount,

    91. 

  91.             authorityCount,

    92. 

  92.             additionalCount;

    93. 

  93.     boolean received,

    94. 

  94.             isResponse,

    95. 

  95.             isAuthAnswer,

    96. 

  96.             isTruncated,

    97. 

  97.             isRecurDesired,

    98. 

  98.             isRecurAvailable,

    99. 

  99.             isBroadcast;

    100. 

  100. 

    101. 

  101.     Name questionName;

    102. 

  102.     Name recordName;

    103. 

  103. 

    104. 

  104.     int questionType,

    105. 

  105.             questionClass,

    106. 

  106.             recordType,

    107. 

  107.             recordClass,

    108. 

  108.             ttl,

    109. 

  109.             rDataLength;

    110. 

  110. 

    111. 

  111.     InetAddress addr;

    112. 

  112. 

    113. 

  113.     NameServicePacket() {

    114. 

  114.         isRecurDesired = true;

    115. 

  115.         isBroadcast = true;

    116. 

  116.         questionCount = 1;

    117. 

  117.         questionClass = IN;

    118. 

  118.     }

    119. 

  119. 

    120. 

  120.     int writeWireFormat( byte[] dst, int dstIndex ) {

    121. 

  121.         int start = dstIndex;

    122. 

  122.         dstIndex += writeHeaderWireFormat( dst, dstIndex );

    123. 

  123.         dstIndex += writeBodyWireFormat( dst, dstIndex );

    124. 

  124.         return dstIndex - start;

    125. 

  125.     }

    126. 

  126.     int readWireFormat( byte[] src, int srcIndex ) {

    127. 

  127.         int start = srcIndex;

    128. 

  128.         srcIndex += readHeaderWireFormat( src, srcIndex );

    129. 

  129.         srcIndex += readBodyWireFormat( src, srcIndex );

    130. 

  130.         return srcIndex - start;

    131. 

  131.     }

    132. 

  132. 

    133. 

  133.     int writeHeaderWireFormat( byte[] dst, int dstIndex ) {

    134. 

  134.         int start = dstIndex;

    135. 

  135.         writeInt2( nameTrnId, dst, dstIndex );

    136. 

  136.         dst[dstIndex + OPCODE_OFFSET] = (byte)(( isResponse ? 0x80 : 0x00 ) +

    137. 

  137.                         (( opCode << 3 ) & 0x78 ) +

    138. 

  138.                         ( isAuthAnswer ? 0x04 : 0x00 ) +

    139. 

  139.                         ( isTruncated ? 0x02 : 0x00 ) +

    140. 

  140.                         ( isRecurDesired ? 0x01 : 0x00 ));

    141. 

  141.         dst[dstIndex + OPCODE_OFFSET + 1] = (byte)(( isRecurAvailable ? 0x80 : 0x00 ) +

    142. 

  142.                         ( isBroadcast ? 0x10 : 0x00 ) +

    143. 

  143.                         ( resultCode & 0x0F ));

    144. 

  144.         writeInt2( questionCount, dst, start + QUESTION_OFFSET );

    145. 

  145.         writeInt2( answerCount, dst, start + ANSWER_OFFSET );

    146. 

  146.         writeInt2( authorityCount, dst, start + AUTHORITY_OFFSET );

    147. 

  147.         writeInt2( additionalCount, dst, start + ADDITIONAL_OFFSET );

    148. 

  148.         return HEADER_LENGTH;

    149. 

  149.     }

    150. 

  150.     int readHeaderWireFormat( byte[] src, int srcIndex ) {

    151. 

  151.         nameTrnId       = readInt2( src, srcIndex );

    152. 

  152.         isResponse      = (( src[srcIndex + OPCODE_OFFSET] & 0x80 ) == 0 ) ? false : true;

    153. 

  153.         opCode          = ( src[srcIndex + OPCODE_OFFSET] & 0x78 ) >> 3;

    154. 

  154.         isAuthAnswer    = (( src[srcIndex + OPCODE_OFFSET] & 0x04 ) == 0 ) ? false : true;

    155. 

  155.         isTruncated     = (( src[srcIndex + OPCODE_OFFSET] & 0x02 ) == 0 ) ? false : true;

    156. 

  156.         isRecurDesired  = (( src[srcIndex + OPCODE_OFFSET] & 0x01 ) == 0 ) ? false : true;

    157. 

  157.         isRecurAvailable =

    158. 

  158.                         (( src[srcIndex + OPCODE_OFFSET + 1] & 0x80 ) == 0 ) ? false : true;

    159. 

  159.         isBroadcast     = (( src[srcIndex + OPCODE_OFFSET + 1] & 0x10 ) == 0 ) ? false : true;

    160. 

  160.         resultCode      = src[srcIndex + OPCODE_OFFSET + 1] & 0x0F;

    161. 

  161.         questionCount   = readInt2( src, srcIndex + QUESTION_OFFSET );

    162. 

  162.         answerCount     = readInt2( src, srcIndex + ANSWER_OFFSET );

    163. 

  163.         authorityCount  = readInt2( src, srcIndex + AUTHORITY_OFFSET );

    164. 

  164.         additionalCount = readInt2( src, srcIndex + ADDITIONAL_OFFSET );

    165. 

  165.         return HEADER_LENGTH;

    166. 

  166.     }

    167. 

  167.     int writeQuestionSectionWireFormat( byte[] dst, int dstIndex ) {

    168. 

  168.         int start = dstIndex;

    169. 

  169.         dstIndex += questionName.writeWireFormat( dst, dstIndex );

    170. 

  170.         writeInt2( questionType, dst, dstIndex );

    171. 

  171.         dstIndex += 2;

    172. 

  172.         writeInt2( questionClass, dst, dstIndex );

    173. 

  173.         dstIndex += 2;

    174. 

  174.         return dstIndex - start;

    175. 

  175.     }

    176. 

  176.     int readQuestionSectionWireFormat( byte[] src, int srcIndex ) {

    177. 

  177.         int start = srcIndex;

    178. 

  178.         srcIndex += questionName.readWireFormat( src, srcIndex );

    179. 

  179.         questionType = readInt2( src, srcIndex );

    180. 

  180.         srcIndex += 2;

    181. 

  181.         questionClass = readInt2( src, srcIndex );

    182. 

  182.         srcIndex += 2;

    183. 

  183.         return srcIndex - start;

    184. 

  184.     }

    185. 

  185.     int writeResourceRecordWireFormat( byte[] dst, int dstIndex ) {

    186. 

  186.         int start = dstIndex;

    187. 

  187.         if( recordName == questionName ) {

    188. 

  188.             dst[dstIndex++] = (byte)0xC0; // label string pointer to

    189. 

  189.             dst[dstIndex++] = (byte)0x0C; // questionName (offset 12)

    190. 

  190.         } else {

    191. 

  191.             dstIndex += recordName.writeWireFormat( dst, dstIndex );

    192. 

  192.         }

    193. 

  193.         writeInt2( recordType, dst, dstIndex );

    194. 

  194.         dstIndex += 2;

    195. 

  195.         writeInt2( recordClass, dst, dstIndex );

    196. 

  196.         dstIndex += 2;

    197. 

  197.         writeInt4( ttl, dst, dstIndex );

    198. 

  198.         dstIndex += 4;

    199. 

  199.         rDataLength = writeRDataWireFormat( dst, dstIndex + 2 );

    200. 

  200.         writeInt2( rDataLength, dst, dstIndex );

    201. 

  201.         dstIndex += 2 + rDataLength;

    202. 

  202.         return dstIndex - start;

    203. 

  203.     }

    204. 

  204.     int readResourceRecordWireFormat( byte[] src, int srcIndex ) {

    205. 

  205.         int start = srcIndex;

    206. 

  206.         int end;

    207. 

  207. 

    208. 

  208.         if(( src[srcIndex] & 0xC0 ) == 0xC0 ) {

    209. 

  209.             recordName = questionName; // label string pointer to questionName

    210. 

  210.             srcIndex += 2;

    211. 

  211.         } else {

    212. 

  212.             srcIndex += recordName.readWireFormat( src, srcIndex );

    213. 

  213.         }

    214. 

  214.         recordType = readInt2( src, srcIndex );

    215. 

  215.         srcIndex += 2;

    216. 

  216.         recordClass = readInt2( src, srcIndex );

    217. 

  217.         srcIndex += 2;

    218. 

  218.         ttl = readInt4( src, srcIndex );

    219. 

  219.         srcIndex += 4;

    220. 

  220.         rDataLength = readInt2( src, srcIndex );

    221. 

  221.         srcIndex += 2;

    222. 

  222. 

    223. 

  223.         addrEntry = new NbtAddress[rDataLength / 6];

    224. 

  224.         end = srcIndex + rDataLength;

    225. 

  225.         for( addrIndex = 0; srcIndex < end; addrIndex++ ) {

    226. 

  226.             srcIndex += readRDataWireFormat( src, srcIndex );

    227. 

  227.         }

    228. 

  228. 

    229. 

  229.         return srcIndex - start;

    230. 

  230.     }

    231. 

  231. 

    232. 

  232.     abstract int writeBodyWireFormat( byte[] dst, int dstIndex );

    233. 

  233.     abstract int readBodyWireFormat( byte[] src, int srcIndex );

    234. 

  234.     abstract int writeRDataWireFormat( byte[] dst, int dstIndex );

    235. 

  235.     abstract int readRDataWireFormat( byte[] src, int srcIndex );

    236. 

  236. 

    237. 

  237.     public String toString() {

    238. 

  238.         String opCodeString,

    239. 

  239.                 resultCodeString,

    240. 

  240.                 questionTypeString,

    241. 

  241.                 questionClassString,

    242. 

  242.                 recordTypeString,

    243. 

  243.                 recordClassString;

    244. 

  244. 

    245. 

  245.         switch( opCode ) {

    246. 

  246.             case QUERY:

    247. 

  247.                 opCodeString = "QUERY";

    248. 

  248.                 break;

    249. 

  249.             case WACK:

    250. 

  250.                 opCodeString = "WACK";

    251. 

  251.                 break;

    252. 

  252.             default:

    253. 

  253.                 opCodeString = Integer.toString( opCode );

    254. 

  254.                 break;

    255. 

  255.         }

    256. 

  256.         switch( resultCode ) {

    257. 

  257.             case FMT_ERR:

    258. 

  258.                 resultCodeString = "FMT_ERR";

    259. 

  259.                 break;

    260. 

  260.             case SRV_ERR:

    261. 

  261.                 resultCodeString = "SRV_ERR";

    262. 

  262.                 break;

    263. 

  263.             case IMP_ERR:

    264. 

  264.                 resultCodeString = "IMP_ERR";

    265. 

  265.                 break;

    266. 

  266.             case RFS_ERR:

    267. 

  267.                 resultCodeString = "RFS_ERR";

    268. 

  268.                 break;

    269. 

  269.             case ACT_ERR:

    270. 

  270.                 resultCodeString = "ACT_ERR";

    271. 

  271.                 break;

    272. 

  272.             case CFT_ERR:

    273. 

  273.                 resultCodeString = "CFT_ERR";

    274. 

  274.                 break;

    275. 

  275.             default:

    276. 

  276.                 resultCodeString = "0x" + Hexdump.toHexString( resultCode, 1 );

    277. 

  277.                 break;

    278. 

  278.         }

    279. 

  279.         switch( questionType ) {

    280. 

  280.             case NB:

    281. 

  281.                 questionTypeString = "NB";

    282. 

  282.                 break;

    283. 

  283.             case NBSTAT:

    284. 

  284.                 questionTypeString = "NBSTAT";

    285. 

  285.                 break;

    286. 

  286.             default:

    287. 

  287.                 questionTypeString = "0x" + Hexdump.toHexString( questionType, 4 );

    288. 

  288.                 break;

    289. 

  289.         }

    290. 

  290.         switch( recordType ) {

    291. 

  291.             case A:

    292. 

  292.                 recordTypeString = "A";

    293. 

  293.                 break;

    294. 

  294.             case NS:

    295. 

  295.                 recordTypeString = "NS";

    296. 

  296.                 break;

    297. 

  297.             case NULL:

    298. 

  298.                 recordTypeString = "NULL";

    299. 

  299.                 break;

    300. 

  300.             case NB:

    301. 

  301.                 recordTypeString = "NB";

    302. 

  302.                 break;

    303. 

  303.             case NBSTAT:

    304. 

  304.                 recordTypeString = "NBSTAT";

    305. 

  305.                 break;

    306. 

  306.             default:

    307. 

  307.                 recordTypeString = "0x" + Hexdump.toHexString( recordType, 4 );

    308. 

  308.                 break;

    309. 

  309.         }

    310. 

  310. 

    311. 

  311.         return new String(

    312. 

  312.                 "nameTrnId=" + nameTrnId +

    313. 

  313.                 ",isResponse=" + isResponse +

    314. 

  314.                 ",opCode=" + opCodeString +

    315. 

  315.                 ",isAuthAnswer=" + isAuthAnswer +

    316. 

  316.                 ",isTruncated=" + isTruncated +

    317. 

  317.                 ",isRecurAvailable=" + isRecurAvailable +

    318. 

  318.                 ",isRecurDesired=" + isRecurDesired +

    319. 

  319.                 ",isBroadcast=" + isBroadcast +

    320. 

  320.                 ",resultCode=" + resultCode +

    321. 

  321.                 ",questionCount=" + questionCount +

    322. 

  322.                 ",answerCount=" + answerCount +

    323. 

  323.                 ",authorityCount=" + authorityCount +

    324. 

  324.                 ",additionalCount=" + additionalCount +

    325. 

  325.                 ",questionName=" + questionName +

    326. 

  326.                 ",questionType=" + questionTypeString +

    327. 

  327.                 ",questionClass=" + ( questionClass == IN ? "IN" :

    328. 

  328.                             "0x" + Hexdump.toHexString( questionClass, 4 )) +

    329. 

  329.                 ",recordName=" + recordName +

    330. 

  330.                 ",recordType=" + recordTypeString +

    331. 

  331.                 ",recordClass=" + ( recordClass == IN ? "IN" :

    332. 

  332.                             "0x" + Hexdump.toHexString( recordClass, 4 )) +

    333. 

  333.                 ",ttl=" + ttl +

    334. 

  334.                 ",rDataLength=" + rDataLength );

    335. 

  335.     }

    336. 

  336. }
    337.