chiark / gitweb /
debugging for thing that crashed
[innduct.git] / authprogs / smbval / session.c
1 /* UNIX RFCNB (RFC1001/RFC1002) NetBIOS implementation
2
3    Version 1.0
4    Session 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 #include <errno.h>
29 #include <netinet/in.h>
30 #include <netinet/tcp.h>
31 #include <sys/socket.h>
32
33 int RFCNB_errno = 0;
34 int RFCNB_saved_errno = 0;
35 #define RFCNB_ERRNO
36
37 #include "rfcnb-priv.h"
38 #include "rfcnb-io.h"
39 #include "rfcnb-util.h"
40
41 int RFCNB_Stats[RFCNB_MAX_STATS];
42
43 void (*Prot_Print_Routine)() = NULL;      /* Pointer to print routine */
44
45 /* Set up a session with a remote name. We are passed Called_Name as a
46    string which we convert to a NetBIOS name, ie space terminated, up to
47    16 characters only if we need to. If Called_Address is not empty, then
48    we use it to connect to the remote end, but put in Called_Name ... Called 
49    Address can be a DNS based name, or a TCP/IP address ...
50 */
51
52 void *RFCNB_Call(char *Called_Name, char *Calling_Name, char *Called_Address,
53                  int port)
54
55 { struct RFCNB_Con *con;
56   struct in_addr Dest_IP;
57   int Client;
58   bool redirect; struct redirect_addr *redir_addr;
59   char *Service_Address;
60
61   /* Now, we really should look up the port in /etc/services ... */
62
63   if (port == 0) port = RFCNB_Default_Port;
64
65   /* Create a connection structure first */
66
67   if ((con = (struct RFCNB_Con *)malloc(sizeof(struct RFCNB_Con))) == NULL) { /* Error in size */
68
69     RFCNB_errno = RFCNBE_NoSpace;
70     RFCNB_saved_errno = errno;
71     return(NULL);
72
73     }
74  
75   con -> fd = -0;             /* no descriptor yet */
76   con -> rfc_errno = 0;           /* no error yet */
77   con -> timeout = 0;         /* no timeout   */
78   con -> redirects = 0;
79   con -> redirect_list = NULL; /* Fix bug still in version 0.50 */
80
81   /* Resolve that name into an IP address */
82
83   Service_Address = Called_Name;
84   if (strcmp(Called_Address, "") != 0) { /* If the Called Address = "" */
85     Service_Address = Called_Address;
86   }
87
88   if ((errno = RFCNB_Name_To_IP(Service_Address, &Dest_IP)) < 0) { /* Error */
89
90     /* No need to modify RFCNB_errno as it was done by RFCNB_Name_To_IP */
91
92     return(NULL);
93
94     }
95
96   /* Now connect to the remote end */
97
98   redirect = true;     /* Fudge this one so we go once through */
99
100   while (redirect) {   /* Connect and get session info etc */
101
102     redirect = false;  /* Assume all OK */
103
104     /* Build the redirect info. First one is first addr called */
105     /* And tack it onto the list of addresses we called        */
106
107     if ((redir_addr = (struct redirect_addr *)malloc(sizeof(struct redirect_addr))) == NULL) { /* Could not get space */
108       
109       RFCNB_errno = RFCNBE_NoSpace;
110       RFCNB_saved_errno = errno;
111       return(NULL);
112
113     }
114
115     memcpy((char *)&(redir_addr -> ip_addr), (char *)&Dest_IP, sizeof(Dest_IP));
116     redir_addr -> port = port;
117     redir_addr -> next = NULL;
118
119     if (con -> redirect_list == NULL) { /* Stick on head */
120
121       con -> redirect_list = con -> last_addr = redir_addr;
122
123     } else {
124
125       con -> last_addr -> next = redir_addr;
126       con -> last_addr = redir_addr;
127
128     }
129
130     /* Now, make that connection */
131
132     if ((Client = RFCNB_IP_Connect(Dest_IP, port)) < 0) { /* Error */
133
134       /* No need to modify RFCNB_errno as it was done by RFCNB_IP_Connect */
135
136       return(NULL);
137
138       }
139
140     con -> fd = Client;
141
142     /* Now send and handle the RFCNB session request              */
143     /* If we get a redirect, we will comeback with redirect true 
144        and a new IP address in DEST_IP                            */
145
146     if ((errno = RFCNB_Session_Req(con, 
147                                    Called_Name,
148                                    Calling_Name,
149                                    &redirect, &Dest_IP, &port)) < 0) {
150
151       /* No need to modify RFCNB_errno as it was done by RFCNB_Session.. */
152
153       return(NULL);
154
155       }
156
157     if (redirect) {
158
159       /* We have to close the connection, and then try again */
160
161       (con -> redirects)++;
162
163       RFCNB_Close(con -> fd);  /* Close it */
164
165       }
166     }
167
168   return(con);
169
170 }
171
172 /* We send a packet to the other end ... for the moment, we treat the 
173    data as a series of pointers to blocks of data ... we should check the
174    length ... */
175
176 int RFCNB_Send(struct RFCNB_Con *Con_Handle, struct RFCNB_Pkt *udata, int Length)
177
178 { struct RFCNB_Pkt *pkt; char *hdr;
179   int len;
180
181   /* Plug in the header and send the data */
182
183   pkt = RFCNB_Alloc_Pkt(RFCNB_Pkt_Hdr_Len);
184
185   if (pkt == NULL) {
186
187     RFCNB_errno = RFCNBE_NoSpace;
188     RFCNB_saved_errno = errno;
189     return(RFCNBE_Bad);
190
191   }
192
193   pkt -> next = udata;   /* The user data we want to send */
194
195   hdr = pkt -> data;
196
197   /* Following crap is for portability across multiple UNIX machines */
198
199   *(hdr + RFCNB_Pkt_Type_Offset)  = RFCNB_SESSION_MESSAGE;
200   RFCNB_Put_Pkt_Len(hdr, Length);
201
202 #ifdef RFCNB_DEBUG
203
204   fprintf(stderr, "Sending packet: ");
205   
206 #endif
207
208   if ((len = RFCNB_Put_Pkt(Con_Handle, pkt, Length + RFCNB_Pkt_Hdr_Len)) < 0) {
209
210     /* No need to change RFCNB_errno as it was done by put_pkt ...     */
211
212     return(RFCNBE_Bad);   /* Should be able to write that lot ... */
213     
214   }
215
216   /* Now we have sent that lot, let's get rid of the RFCNB Header and return */
217
218   pkt -> next = NULL;
219
220   RFCNB_Free_Pkt(pkt);
221
222   return(len);
223
224 }
225
226 /* We pick up a message from the internet ... We have to worry about 
227    non-message packets ...                                           */
228
229 int RFCNB_Recv(void *con_Handle, struct RFCNB_Pkt *Data, int Length)
230
231 { struct RFCNB_Pkt *pkt;
232   int ret_len;
233
234   if (con_Handle == NULL){
235
236     RFCNB_errno = RFCNBE_BadHandle;
237     RFCNB_saved_errno = errno;
238     return(RFCNBE_Bad);
239
240   }
241
242   /* Now get a packet from below. We allocate a header first */
243
244   /* Plug in the header and send the data */
245
246   pkt = RFCNB_Alloc_Pkt(RFCNB_Pkt_Hdr_Len);
247
248   if (pkt == NULL) {
249
250     RFCNB_errno = RFCNBE_NoSpace;
251     RFCNB_saved_errno = errno;
252     return(RFCNBE_Bad);
253
254   }
255
256   pkt -> next = Data;  /* Plug in the data portion */
257
258   if ((ret_len = RFCNB_Get_Pkt(con_Handle, pkt, Length + RFCNB_Pkt_Hdr_Len)) < 0) {
259
260 #ifdef RFCNB_DEBUG
261     fprintf(stderr, "Bad packet return in RFCNB_Recv... \n");
262 #endif
263
264     return(RFCNBE_Bad);
265
266   }
267
268   /* We should check that we go a message and not a keep alive */
269
270   pkt -> next = NULL;
271
272   RFCNB_Free_Pkt(pkt);
273
274   return(ret_len);
275
276 }
277
278 /* We just disconnect from the other end, as there is nothing in the RFCNB */
279 /* protocol that specifies any exchange as far as I can see                */
280
281 int RFCNB_Hangup(struct RFCNB_Con *con_Handle)
282
283 {
284
285   if (con_Handle != NULL) {
286     RFCNB_Close(con_Handle -> fd);  /* Could this fail? */
287     free(con_Handle);
288   }
289
290   return 0;
291
292
293 }
294
295 /* Set TCP_NODELAY on the socket                                          */
296
297 int RFCNB_Set_Sock_NoDelay(struct RFCNB_Con *con_Handle, bool yn)
298
299 {
300
301   return(setsockopt(con_Handle -> fd, IPPROTO_TCP, TCP_NODELAY, 
302                     (char *)&yn, sizeof(yn)));
303
304 }