1 /* UNIX RFCNB (RFC1001/RFC1002) NetBIOS implementation
6 Copyright (C) Richard Sharpe 1996
7 Copyright 2006 The FreeRADIUS server project
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include <freeradius-devel/ident.h>
33 int RFCNB_saved_errno = 0;
36 #include "std-includes.h"
38 #ifdef HAVE_NETINET_TCP_H
39 #include <netinet/tcp.h>
42 #include "rfcnb-priv.h"
43 #include "rfcnb-util.h"
45 int RFCNB_Stats[RFCNB_MAX_STATS];
47 void (*Prot_Print_Routine)() = NULL; /* Pointer to print routine */
49 /* Set up a session with a remote name. We are passed Called_Name as a
50 string which we convert to a NetBIOS name, ie space terminated, up to
51 16 characters only if we need to. If Called_Address is not empty, then
52 we use it to connect to the remote end, but put in Called_Name ... Called
53 Address can be a DNS based name, or a TCP/IP address ...
56 void *RFCNB_Call(char *Called_Name, char *Calling_Name, char *Called_Address,
59 { struct RFCNB_Con *con;
60 struct in_addr Dest_IP;
62 BOOL redirect; struct redirect_addr *redir_addr;
63 char *Service_Address;
65 /* Now, we really should look up the port in /etc/services ... */
67 if (port == 0) port = RFCNB_Default_Port;
69 /* Create a connection structure first */
71 if ((con = (struct RFCNB_Con *)malloc(sizeof(struct RFCNB_Con))) == NULL) { /* Error in size */
73 RFCNB_errno = RFCNBE_NoSpace;
74 RFCNB_saved_errno = errno;
79 con -> fd = -0; /* no descriptor yet */
80 con -> rfc_errno = 0; /* no error yet */
81 con -> timeout = 0; /* no timeout */
83 con -> redirect_list = NULL; /* Fix bug still in version 0.50 */
85 /* Resolve that name into an IP address */
87 Service_Address = Called_Name;
88 if (strcmp(Called_Address, "") != 0) { /* If the Called Address = "" */
89 Service_Address = Called_Address;
92 if ((errno = RFCNB_Name_To_IP(Service_Address, &Dest_IP)) < 0) { /* Error */
94 /* No need to modify RFCNB_errno as it was done by RFCNB_Name_To_IP */
100 /* Now connect to the remote end */
102 redirect = TRUE; /* Fudge this one so we go once through */
104 while (redirect) { /* Connect and get session info etc */
106 redirect = FALSE; /* Assume all OK */
108 /* Build the redirect info. First one is first addr called */
109 /* And tack it onto the list of addresses we called */
111 if ((redir_addr = (struct redirect_addr *)malloc(sizeof(struct redirect_addr))) == NULL) { /* Could not get space */
113 RFCNB_errno = RFCNBE_NoSpace;
114 RFCNB_saved_errno = errno;
119 memcpy((char *)&(redir_addr -> ip_addr), (char *)&Dest_IP, sizeof(Dest_IP));
120 redir_addr -> port = port;
121 redir_addr -> next = NULL;
123 if (con -> redirect_list == NULL) { /* Stick on head */
125 con -> redirect_list = con -> last_addr = redir_addr;
129 con -> last_addr -> next = redir_addr;
130 con -> last_addr = redir_addr;
134 /* Now, make that connection */
136 if ((Client = RFCNB_IP_Connect(Dest_IP, port)) < 0) { /* Error */
138 /* No need to modify RFCNB_errno as it was done by RFCNB_IP_Connect */
146 /* Now send and handle the RFCNB session request */
147 /* If we get a redirect, we will comeback with redirect true
148 and a new IP address in DEST_IP */
150 if ((errno = RFCNB_Session_Req(con,
153 &redirect, &Dest_IP, &port)) < 0) {
155 /* No need to modify RFCNB_errno as it was done by RFCNB_Session.. */
163 /* We have to close the connection, and then try again */
165 (con -> redirects)++;
167 RFCNB_Close(con -> fd); /* Close it */
176 /* We send a packet to the other end ... for the moment, we treat the
177 data as a series of pointers to blocks of data ... we should check the
180 int RFCNB_Send(struct RFCNB_Con *Con_Handle, struct RFCNB_Pkt *udata, int Length)
182 { struct RFCNB_Pkt *pkt; char *hdr;
185 /* Plug in the header and send the data */
187 pkt = RFCNB_Alloc_Pkt(RFCNB_Pkt_Hdr_Len);
191 RFCNB_errno = RFCNBE_NoSpace;
192 RFCNB_saved_errno = errno;
197 pkt -> next = udata; /* The user data we want to send */
201 /* Following crap is for portability across multiple UNIX machines */
203 *(hdr + RFCNB_Pkt_Type_Offset) = RFCNB_SESSION_MESSAGE;
204 RFCNB_Put_Pkt_Len(hdr, Length);
208 fprintf(stderr, "Sending packet: ");
212 if ((len = RFCNB_Put_Pkt(Con_Handle, pkt, Length + RFCNB_Pkt_Hdr_Len)) < 0) {
214 /* No need to change RFCNB_errno as it was done by put_pkt ... */
216 return(RFCNBE_Bad); /* Should be able to write that lot ... */
220 /* Now we have sent that lot, let's get rid of the RFCNB Header and return */
230 /* We pick up a message from the internet ... We have to worry about
231 non-message packets ... */
233 int RFCNB_Recv(void *con_Handle, struct RFCNB_Pkt *Data, int Length)
236 struct RFCNB_Pkt *pkt;
239 if (con_Handle == NULL){
241 RFCNB_errno = RFCNBE_BadHandle;
242 RFCNB_saved_errno = errno;
247 /* Now get a packet from below. We allocate a header first */
249 /* Plug in the header and send the data */
251 pkt = RFCNB_Alloc_Pkt(RFCNB_Pkt_Hdr_Len);
255 RFCNB_errno = RFCNBE_NoSpace;
256 RFCNB_saved_errno = errno;
261 pkt -> next = Data; /* Plug in the data portion */
263 if ((ret_len = RFCNB_Get_Pkt(con_Handle, pkt, Length + RFCNB_Pkt_Hdr_Len)) < 0) {
266 fprintf(stderr, "Bad packet return in RFCNB_Recv... \n");
273 /* We should check that we go a message and not a keep alive */
283 /* We just disconnect from the other end, as there is nothing in the RFCNB */
284 /* protocol that specifies any exchange as far as I can see */
286 int RFCNB_Hangup(struct RFCNB_Con *con_Handle)
290 if (con_Handle != NULL) {
291 RFCNB_Close(con_Handle -> fd); /* Could this fail? */
300 /* Set TCP_NODELAY on the socket */
302 int RFCNB_Set_Sock_NoDelay(struct RFCNB_Con *con_Handle, BOOL yn)
306 return(setsockopt(con_Handle -> fd, IPPROTO_TCP, TCP_NODELAY,
307 (char *)&yn, sizeof(yn)));
312 /* Listen for a connection on a port???, when */
313 /* the connection comes in, we return with the connection */
321 /* Pick up the last error response as a string, hmmm, this routine should */
322 /* have been different ... */
324 void RFCNB_Get_Error(char *buffer, int buf_len)
328 if (RFCNB_saved_errno <= 0) {
329 sprintf(buffer, "%s", RFCNB_Error_Strings[RFCNB_errno]);
332 sprintf(buffer, "%s\n\terrno:%s", RFCNB_Error_Strings[RFCNB_errno],
333 strerror(RFCNB_saved_errno));
338 /* Pick up the last error response and returns as a code */
340 int RFCNB_Get_Last_Error()
348 /* Pick up saved errno as well */
350 int RFCNB_Get_Last_Errno()
354 return(RFCNB_saved_errno);
358 /* Pick up the last error response and return in string ... */
360 int RFCNB_Get_Error_Msg(int code, char *msg_buf, int len)
364 strncpy(msg_buf, RFCNB_Error_Strings[abs(code)], len);
368 /* Register a higher level protocol print routine */
370 void RFCNB_Register_Print_Routine(void (*fn)())
374 Prot_Print_Routine = fn;