chiark / gitweb /
debugging for thing that crashed
[innduct.git] / authprogs / smbval / smblib-util.c
1 /* UNIX SMBlib NetBIOS implementation
2
3    Version 1.0
4    SMBlib Utility Routines
5
6    Copyright (C) Richard Sharpe 1996
7
8 */
9
10 /*
11    This program is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 2 of the License, or
14    (at your option) any later version.
15    
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20    
21    You should have received a copy of the GNU General Public License
22    along with this program; if not, write to the Free Software
23    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26 #include "config.h"
27 #include "clibrary.h"
28
29 #include "smblib-priv.h"
30 #include "rfcnb.h"
31
32 /* The following two arrays need to be in step!              */
33 /* We must make it possible for callers to specify these ... */
34
35 const char *SMB_Prots[] = {"PC NETWORK PROGRAM 1.0", 
36                            "MICROSOFT NETWORKS 1.03",
37                            "MICROSOFT NETWORKS 3.0",
38                            "DOS LANMAN1.0",
39                            "LANMAN1.0",
40                            "DOS LM1.2X002",
41                            "LM1.2X002",
42                            "DOS LANMAN2.1",
43                            "LANMAN2.1",
44                            "Samba",
45                            "NT LM 0.12",
46                            "NT LANMAN 1.0",
47                            NULL};
48
49 int SMB_Types[] = {SMB_P_Core,
50                    SMB_P_CorePlus,
51                    SMB_P_DOSLanMan1,
52                    SMB_P_DOSLanMan1,
53                    SMB_P_LanMan1,
54                    SMB_P_DOSLanMan2,
55                    SMB_P_LanMan2,
56                    SMB_P_LanMan2_1,
57                    SMB_P_LanMan2_1,
58                    SMB_P_NT1,
59                    SMB_P_NT1,
60                    SMB_P_NT1,
61                    -1};
62
63 /* Figure out what protocol was accepted, given the list of dialect strings */
64 /* We offered, and the index back from the server. We allow for a user      */
65 /* supplied list, and assume that it is a subset of our list                */
66
67 int SMB_Figure_Protocol(const char *dialects[], int prot_index)
68
69 { int i;
70
71   if (dialects == SMB_Prots) { /* The jobs is easy, just index into table */
72
73     return(SMB_Types[prot_index]);
74   }
75   else { /* Search through SMB_Prots looking for a match */
76
77     for (i = 0; SMB_Prots[i] != NULL; i++) {
78
79       if (strcmp(dialects[prot_index], SMB_Prots[i]) == 0) { /* A match */
80
81         return(SMB_Types[i]);
82
83       }
84
85     }
86
87     /* If we got here, then we are in trouble, because the protocol was not */
88     /* One we understand ...                                                */
89
90     return(SMB_P_Unknown);
91
92   }
93
94 }
95
96
97 /* Negotiate the protocol we will use from the list passed in Prots       */
98 /* we return the index of the accepted protocol in NegProt, -1 indicates  */
99 /* none acceptible, and our return value is 0 if ok, <0 if problems       */
100
101 int SMB_Negotiate(SMB_Handle_Type Con_Handle, const char *Prots[])
102 {
103   struct RFCNB_Pkt *pkt;
104   int prots_len, i, pkt_len, prot, alloc_len;
105   char *p;
106
107   /* Figure out how long the prot list will be and allocate space for it */
108
109   prots_len = 0;
110
111   for (i = 0; Prots[i] != NULL; i++) {
112
113     prots_len = prots_len + strlen(Prots[i]) + 2; /* Account for null etc */
114
115   }
116
117   /* The -1 accounts for the one byte smb_buf we have because some systems */
118   /* don't like char msg_buf[]                                             */
119
120   pkt_len = SMB_negp_len + prots_len;
121
122   /* Make sure that the pkt len is long enough for the max response ...   */
123   /* Which is a problem, because the encryption key len eec may be long   */
124
125   if (pkt_len < (SMB_hdr_wct_offset + (19 * 2) + 40)) {
126
127     alloc_len = SMB_hdr_wct_offset + (19 * 2) + 40;
128
129   }
130   else {
131
132     alloc_len = pkt_len;
133
134   }
135
136   pkt = (struct RFCNB_Pkt *)RFCNB_Alloc_Pkt(alloc_len);
137
138   if (pkt == NULL) {
139
140     SMBlib_errno = SMBlibE_NoSpace;
141     return(SMBlibE_BAD);
142
143   }
144
145   /* Now plug in the bits we need */
146
147   memset(SMB_Hdr(pkt), 0, SMB_negp_len);
148   SIVAL(SMB_Hdr(pkt), SMB_hdr_idf_offset, SMB_DEF_IDF);  /* Plunk in IDF */
149   *(SMB_Hdr(pkt) + SMB_hdr_com_offset) = SMBnegprot;
150   SSVAL(SMB_Hdr(pkt), SMB_hdr_pid_offset, Con_Handle -> pid);
151   SSVAL(SMB_Hdr(pkt), SMB_hdr_tid_offset, 0);
152   SSVAL(SMB_Hdr(pkt), SMB_hdr_mid_offset, Con_Handle -> mid);
153   SSVAL(SMB_Hdr(pkt), SMB_hdr_uid_offset, Con_Handle -> uid);
154   *(SMB_Hdr(pkt) + SMB_hdr_wct_offset) = 0;
155
156   SSVAL(SMB_Hdr(pkt), SMB_negp_bcc_offset, prots_len);
157
158   /* Now copy the prot strings in with the right stuff */
159
160   p = (char *)(SMB_Hdr(pkt) + SMB_negp_buf_offset);
161
162   for (i = 0; Prots[i] != NULL; i++) {
163
164     *p = SMBdialectID;
165     strcpy(p + 1, Prots[i]);
166     p = p + strlen(Prots[i]) + 2; /* Adjust len of p for null plus dialectID */
167
168   }
169
170   /* Now send the packet and sit back ... */
171
172   if (RFCNB_Send(Con_Handle -> Trans_Connect, pkt, pkt_len) < 0){
173
174
175 #ifdef DEBUG
176     fprintf(stderr, "Error sending negotiate protocol\n");
177 #endif
178
179     RFCNB_Free_Pkt(pkt);
180     SMBlib_errno = -SMBlibE_SendFailed; /* Failed, check lower layer errno */
181     return(SMBlibE_BAD);
182
183   }
184
185   /* Now get the response ... */
186
187   if (RFCNB_Recv(Con_Handle -> Trans_Connect, pkt, alloc_len) < 0) {
188
189 #ifdef DEBUG
190     fprintf(stderr, "Error receiving response to negotiate\n");
191 #endif
192
193     RFCNB_Free_Pkt(pkt);
194     SMBlib_errno = -SMBlibE_RecvFailed; /* Failed, check lower layer errno */
195     return(SMBlibE_BAD);
196
197   }
198
199   if (CVAL(SMB_Hdr(pkt), SMB_hdr_rcls_offset) != SMBC_SUCCESS) {  /* Process error */
200
201 #ifdef DEBUG
202     fprintf(stderr, "SMB_Negotiate failed with errorclass = %i, Error Code = %i\n",
203             CVAL(SMB_Hdr(pkt), SMB_hdr_rcls_offset),
204             SVAL(SMB_Hdr(pkt), SMB_hdr_err_offset));
205 #endif
206
207     SMBlib_SMB_Error = IVAL(SMB_Hdr(pkt), SMB_hdr_rcls_offset);
208     RFCNB_Free_Pkt(pkt);
209     SMBlib_errno = SMBlibE_Remote;
210     return(SMBlibE_BAD);
211
212   }
213   
214   if (SVAL(SMB_Hdr(pkt), SMB_negrCP_idx_offset) == 0xFFFF) {
215
216 #ifdef DEBUG
217     fprintf(stderr, "None of our protocols was accepted ... ");
218 #endif
219
220     RFCNB_Free_Pkt(pkt);
221     SMBlib_errno = SMBlibE_NegNoProt;
222     return(SMBlibE_BAD);
223
224   }
225
226   /* Now, unpack the info from the response, if any and evaluate the proto */
227   /* selected. We must make sure it is one we like ...                     */
228
229   Con_Handle -> prot_IDX = prot = SVAL(SMB_Hdr(pkt), SMB_negrCP_idx_offset);
230   Con_Handle -> protocol = SMB_Figure_Protocol(Prots, prot);
231
232   if (Con_Handle -> protocol == SMB_P_Unknown) { /* No good ... */
233
234     RFCNB_Free_Pkt(pkt);
235     SMBlib_errno = SMBlibE_ProtUnknown;
236     return(SMBlibE_BAD);
237
238   }
239   
240   switch (CVAL(SMB_Hdr(pkt), SMB_hdr_wct_offset)) {
241
242   case 0x01:      /* No more info ... */
243
244     break;
245
246   case 13:        /* Up to and including LanMan 2.1 */
247
248     Con_Handle -> Security = SVAL(SMB_Hdr(pkt), SMB_negrLM_sec_offset);
249     Con_Handle -> encrypt_passwords = ((Con_Handle -> Security & SMB_sec_encrypt_mask) != 0x00);
250     Con_Handle -> Security = Con_Handle -> Security & SMB_sec_user_mask;
251
252     Con_Handle -> max_xmit = SVAL(SMB_Hdr(pkt), SMB_negrLM_mbs_offset);
253     Con_Handle -> MaxMPX = SVAL(SMB_Hdr(pkt), SMB_negrLM_mmc_offset);
254     Con_Handle -> MaxVC = SVAL(SMB_Hdr(pkt), SMB_negrLM_mnv_offset);
255     Con_Handle -> Raw_Support = SVAL(SMB_Hdr(pkt), SMB_negrLM_rm_offset);
256     Con_Handle -> SessionKey = IVAL(SMB_Hdr(pkt), SMB_negrLM_sk_offset);
257     Con_Handle -> SvrTZ = SVAL(SMB_Hdr(pkt), SMB_negrLM_stz_offset);
258     Con_Handle -> Encrypt_Key_Len = SVAL(SMB_Hdr(pkt), SMB_negrLM_ekl_offset);
259     
260     p = (SMB_Hdr(pkt) + SMB_negrLM_buf_offset);
261     fprintf(stderr, "%p", (char *)(SMB_Hdr(pkt) + SMB_negrLM_buf_offset));
262     memcpy(Con_Handle->Encrypt_Key, p, 8);
263
264     p = (SMB_Hdr(pkt) + SMB_negrLM_buf_offset + Con_Handle -> Encrypt_Key_Len);
265
266     strncpy(p, Con_Handle -> Svr_PDom, sizeof(Con_Handle -> Svr_PDom) - 1);
267
268     break;
269
270   case 17:        /* NT LM 0.12 and LN LM 1.0 */
271
272     Con_Handle -> Security = SVAL(SMB_Hdr(pkt), SMB_negrNTLM_sec_offset);
273     Con_Handle -> encrypt_passwords = ((Con_Handle -> Security & SMB_sec_encrypt_mask) != 0x00);
274     Con_Handle -> Security = Con_Handle -> Security & SMB_sec_user_mask;
275
276     Con_Handle -> max_xmit = IVAL(SMB_Hdr(pkt), SMB_negrNTLM_mbs_offset);
277     Con_Handle -> MaxMPX = SVAL(SMB_Hdr(pkt), SMB_negrNTLM_mmc_offset);
278     Con_Handle -> MaxVC = SVAL(SMB_Hdr(pkt), SMB_negrNTLM_mnv_offset);
279     Con_Handle -> MaxRaw = IVAL(SMB_Hdr(pkt), SMB_negrNTLM_mrs_offset);
280     Con_Handle -> SessionKey = IVAL(SMB_Hdr(pkt), SMB_negrNTLM_sk_offset);
281     Con_Handle -> SvrTZ = SVAL(SMB_Hdr(pkt), SMB_negrNTLM_stz_offset);
282     Con_Handle -> Encrypt_Key_Len = CVAL(SMB_Hdr(pkt), SMB_negrNTLM_ekl_offset);
283
284     p = (SMB_Hdr(pkt) + SMB_negrNTLM_buf_offset );
285     memcpy(Con_Handle -> Encrypt_Key, p, 8);
286     p = (SMB_Hdr(pkt) + SMB_negrNTLM_buf_offset + Con_Handle -> Encrypt_Key_Len);
287
288     strncpy(p, Con_Handle -> Svr_PDom, sizeof(Con_Handle -> Svr_PDom) - 1);
289
290     break;
291
292   default:
293
294 #ifdef DEBUG
295     fprintf(stderr, "Unknown NegProt response format ... Ignored\n");
296     fprintf(stderr, "  wct = %i\n", CVAL(SMB_Hdr(pkt), SMB_hdr_wct_offset));
297 #endif
298
299     break;
300   }
301
302 #ifdef DEBUG
303   fprintf(stderr, "Protocol selected is: %i:%s\n", prot, Prots[prot]);
304 #endif
305
306   RFCNB_Free_Pkt(pkt);
307   return(0);
308
309 }
310
311 /* Get our hostname */
312
313 void SMB_Get_My_Name(char *name, int len)
314
315 {
316   if (gethostname(name, len) < 0) { /* Error getting name */
317
318     strncpy(name, "unknown", len);
319
320     /* Should check the error */
321
322 #ifdef DEBUG
323     fprintf(stderr, "gethostname in SMB_Get_My_Name returned error:");
324     perror("");
325 #endif
326
327   }
328
329   /* only keep the portion up to the first "." */
330
331
332 }