len = smb_len(inbuf);    msg_type = CVAL(inbuf,0);    if (msg_type == 0x85)       DEBUG(5,("Got keepalive packet\n"));  }  DEBUG(10,("got smb length of %d\n",len));  return(len);}/****************************************************************************read 4 bytes of a smb packet and return the smb length of the packetstore the result in the buffer. This version of the function willnever return a session keepalive (length of zero).timeout is in milliseconds.****************************************************************************/ssize_t read_smb_length(int fd,char *inbuf,unsigned int timeout){  ssize_t len;  for(;;)  {    len = read_smb_length_return_keepalive(fd, inbuf, timeout);    if(len < 0)      return len;    /* Ignore session keepalives. */    if(CVAL(inbuf,0) != 0x85)      break;  }  DEBUG(10,("read_smb_length: got smb length of %d\n",len));  return len;}/****************************************************************************  read an smb from a fd. Note that the buffer *MUST* be of size  BUFFER_SIZE+SAFETY_MARGIN.  The timeout is in milliseconds.   This function will return on a  receipt of a session keepalive packet.****************************************************************************/BOOL receive_smb(int fd,char *buffer, unsigned int timeout){  ssize_t len,ret;  smb_read_error = 0;  memset(buffer,'\0',smb_size + 100);  len = read_smb_length_return_keepalive(fd,buffer,timeout);  if (len < 0)  {    DEBUG(10,("receive_smb: length < 0!\n"));    return(False);  }  if (len > BUFFER_SIZE) {    DEBUG(0,("Invalid packet length! (%d bytes).\n",len));    if (len > BUFFER_SIZE + (SAFETY_MARGIN/2))    {	exit(1);    }  }  if(len > 0) {    ret = read_data(fd,buffer+4,len);    if (ret != len) {      smb_read_error = READ_ERROR;      return False;    }  }  return(True);}/****************************************************************************  read an smb from a fd ignoring all keepalive packets. Note that the buffer   *MUST* be of size BUFFER_SIZE+SAFETY_MARGIN.  The timeout is in milliseconds  This is exactly the same as receive_smb except that it never returns  a session keepalive packet (just as receive_smb used to do).  receive_smb was changed to return keepalives as the oplock processing means this call  should never go into a blocking read.****************************************************************************/BOOL client_receive_smb(int fd,char *buffer, unsigned int timeout){  BOOL ret;  for(;;)  {    ret = receive_smb(fd, buffer, timeout);    if (!ret)    {      DEBUG(10,("client_receive_smb failed\n"));      show_msg(buffer);      return ret;    }    /* Ignore session keepalive packets. */    if(CVAL(buffer,0) != 0x85)      break;  }  show_msg(buffer);  return ret;}/****************************************************************************  send an null session message to a fd****************************************************************************/BOOL send_null_session_msg(int fd){  ssize_t ret;  uint32 blank = 0;  size_t len = 4;  size_t nwritten=0;  char *buffer = (char *)&blank;  while (nwritten < len)  {    ret = write_socket(fd,buffer+nwritten,len - nwritten);    if (ret <= 0)    {      DEBUG(0,("send_null_session_msg: Error writing %d bytes to client. %d. Exiting\n",(int)len,(int)ret));      close_sockets();      exit(1);    }    nwritten += ret;  }  DEBUG(10,("send_null_session_msg: sent 4 null bytes to client.\n"));  return True;}/****************************************************************************  send an smb to a fd ****************************************************************************/BOOL send_smb(int fd,char *buffer){  size_t len;  size_t nwritten=0;  ssize_t ret;  len = smb_len(buffer) + 4;  while (nwritten < len)  {    ret = write_socket(fd,buffer+nwritten,len - nwritten);    if (ret <= 0)    {      DEBUG(0,("Error writing %d bytes to client. %d. Exiting\n",(int)len,(int)ret));      close_sockets();      exit(1);    }    nwritten += ret;  }  return True;}/****************************************************************************send a single packet to a port on another machine****************************************************************************/BOOL send_one_packet(char *buf,int len,struct in_addr ip,int port,int type){  BOOL ret;  int out_fd;  struct sockaddr_in sock_out;  if (passive)    return(True);  /* create a socket to write to */  out_fd = socket(AF_INET, type, 0);  if (out_fd == -1)     {      DEBUG(0,("socket failed"));      return False;    }  /* set the address and port */  memset((char *)&sock_out,'\0',sizeof(sock_out));  putip((char *)&sock_out.sin_addr,(char *)&ip);  sock_out.sin_port = htons( port );  sock_out.sin_family = AF_INET;    if (DEBUGLEVEL > 0)    DEBUG(3,("sending a packet of len %d to (%s) on port %d of type %s\n",	     len,inet_ntoa(ip),port,type==SOCK_DGRAM?"DGRAM":"STREAM"));	  /* send it */  ret = (sendto(out_fd,buf,len,0,(struct sockaddr *)&sock_out,sizeof(sock_out)) >= 0);  if (!ret)    DEBUG(0,("Packet send to %s(%d) failed ERRNO=%s\n",	     inet_ntoa(ip),port,strerror(errno)));  close(out_fd);  return(ret);}/****************************************************************************open a socket of the specified type, port and address for incoming data****************************************************************************/int open_socket_in(int type, int port, int dlevel,uint32 socket_addr, BOOL rebind){  struct hostent *hp;  struct sockaddr_in sock;  pstring host_name;  int res;  /* get my host name */  if (gethostname(host_name, MAXHOSTNAMELEN) == -1)     { DEBUG(0,("gethostname failed\n")); return -1; }   /* get host info */  if ((hp = Get_Hostbyname(host_name)) == 0)     {      DEBUG(0,( "Get_Hostbyname: Unknown host %s\n",host_name));      return -1;    }    memset((char *)&sock,'\0',sizeof(sock));  memcpy((char *)&sock.sin_addr,(char *)hp->h_addr, hp->h_length);#ifdef HAVE_SOCK_SIN_LEN  sock.sin_len = sizeof(sock);#endif  sock.sin_port = htons( port );  sock.sin_family = hp->h_addrtype;  sock.sin_addr.s_addr = socket_addr;  res = socket(hp->h_addrtype, type, 0);  if (res == -1)     { DEBUG(0,("socket failed\n")); return -1; }  {    int val=1;	if(rebind)		val=1;	else		val=0;    setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val));  }  /* now we've got a socket - we need to bind it */  if (bind(res, (struct sockaddr * ) &sock,sizeof(sock)) < 0)     {       if (port) {	if (port == SMB_PORT || port == NMB_PORT)	  DEBUG(dlevel,("bind failed on port %d socket_addr=%s (%s)\n",			port,inet_ntoa(sock.sin_addr),strerror(errno))); 	close(res); 	if (dlevel > 0 && port < 1000)	  port = 7999;	if (port >= 1000 && port < 9000)	  return(open_socket_in(type,port+1,dlevel,socket_addr,rebind));      }      return(-1);     }  DEBUG(3,("bind succeeded on port %d\n",port));  return res;}/****************************************************************************  create an outgoing socket. timeout is in milliseconds.  **************************************************************************/int open_socket_out(int type, struct in_addr *addr, int port ,int timeout){  struct sockaddr_in sock_out;  int res,ret;  int connect_loop = 250; /* 250 milliseconds */  int loops = (timeout) / connect_loop;  /* create a socket to write to */  res = socket(PF_INET, type, 0);  if (res == -1)     { DEBUG(0,("socket error\n")); return -1; }  if (type != SOCK_STREAM) return(res);    memset((char *)&sock_out,'\0',sizeof(sock_out));  putip((char *)&sock_out.sin_addr,(char *)addr);    sock_out.sin_port = htons( port );  sock_out.sin_family = PF_INET;  /* set it non-blocking */  set_blocking(res,False);  DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));    /* and connect it to the destination */connect_again:  ret = connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out));  /* Some systems return EAGAIN when they mean EINPROGRESS */  if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||        errno == EAGAIN) && loops--) {    msleep(connect_loop);    goto connect_again;  }  if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||         errno == EAGAIN)) {      DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));      close(res);      return -1;  }#ifdef EISCONN  if (ret < 0 && errno == EISCONN) {    errno = 0;    ret = 0;  }#endif  if (ret < 0) {    DEBUG(1,("error connecting to %s:%d (%s)\n",	     inet_ntoa(*addr),port,strerror(errno)));    close(res);    return -1;  }  /* set it blocking again */  set_blocking(res,True);  return res;}/******************************************************************* Reset the 'done' variables so after a client process is created from a fork call these calls will be re-done. This should be expanded if more variables need reseting. ******************************************************************/static BOOL global_client_name_done = False;static BOOL global_client_addr_done = False;void reset_globals_after_fork(void){  global_client_name_done = False;  global_client_addr_done = False;  /*   * Re-seed the random crypto generator, so all smbd's   * started from the same parent won't generate the same   * sequence.   */  {    unsigned char dummy;    generate_random_buffer( &dummy, 1, True);  } } /******************************************************************* return the DNS name of the client  ******************************************************************/char *client_name(int fd){	struct sockaddr sa;	struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);	int     length = sizeof(sa);	static pstring name_buf;	struct hostent *hp;	static int last_fd=-1;		if (global_client_name_done && last_fd == fd) 		return name_buf;		last_fd = fd;	global_client_name_done = False;		pstrcpy(name_buf,"UNKNOWN");		if (fd == -1) {		return name_buf;	}		if (getpeername(fd, &sa, &length) < 0) {		DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));		return name_buf;	}		/* Look up the remote host name. */	if ((hp = gethostbyaddr((char *) &sockin->sin_addr,				sizeof(sockin->sin_addr),				AF_INET)) == 0) {		DEBUG(1,("Gethostbyaddr failed for %s\n",client_addr(fd)));		StrnCpy(name_buf,client_addr(fd),sizeof(name_buf) - 1);	} else {		StrnCpy(name_buf,(char *)hp->h_name,sizeof(name_buf) - 1);		if (!matchname(name_buf, sockin->sin_addr)) {			DEBUG(0,("Matchname failed on %s %s\n",name_buf,client_addr(fd)));			pstrcpy(name_buf,"UNKNOWN");		}	}	global_client_name_done = True;	return name_buf;}/******************************************************************* return the IP addr of the client as a string  ******************************************************************/char *client_addr(int fd){	struct sockaddr sa;	struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);	int     length = sizeof(sa);	static fstring addr_buf;	static int last_fd = -1;	if (global_client_addr_done && fd == last_fd) 		return addr_buf;	last_fd = fd;	global_client_addr_done = False;	fstrcpy(addr_buf,"0.0.0.0");	if (fd == -1) {		return addr_buf;	}		if (getpeername(fd, &sa, &length) < 0) {		DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));		return addr_buf;	}		fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));		global_client_addr_done = True;	return addr_buf;}