//=============================================================================
// RcvFile - Подпрограмма получения файла
//=============================================================================
BOOL RcvFile(int sock, char *FileName)
{
FILE *File;
char RecvBuf[FILEBUFLEN+L1];
struct timeval mytimeout;
fd_set r;
int i;

  File = fopen(FileName, "wb");
  mytimeout.tv_sec = TO_FILE;  // ждем сколько надо
  mytimeout.tv_usec = L0;

  FD_ZERO(&r);
  myFD_SET(sock, &r);

  for ( ;; )
    {
    if ( select(sock+1, &r, NULL, NULL, &mytimeout) <= 0 ) break;
    DosSleep(10); // немного подождем
    if ( (i=recv(sock, RecvBuf, sizeof(RecvBuf), L0)) <= L1 ) break;

    fwrite(RecvBuf+1, i-1, L1, File);
    if ( RecvBuf[0] != 0 ) continue;

    soclose(sock);
    fclose(File);
    return TRUE;
    }

// Обработка ошибок
  soclose(sock);
  fclose(File);
  DosDelete(FileName);
  return FALSE;
}

/* ARGSUSED */
int
fifo_close(void *v)
{
	struct vop_close_args *ap = v;
	struct vnode *vp = ap->a_vp;
	struct fifoinfo *fip = vp->v_fifoinfo;
	int error1 = 0, error2 = 0;

	if (fip == NULL)
		return (0);

	if (ap->a_fflag & FREAD) {
		if (--fip->fi_readers == 0)
			socantsendmore(fip->fi_writesock);
	}
	if (ap->a_fflag & FWRITE) {
		if (--fip->fi_writers == 0)
			socantrcvmore(fip->fi_readsock);
	}
	if (fip->fi_readers == 0 && fip->fi_writers == 0) {
		error1 = soclose(fip->fi_readsock);
		error2 = soclose(fip->fi_writesock);
		free(fip, M_VNODE);
		vp->v_fifoinfo = NULL;
	}
	return (error1 ? error1 : error2);
}

void accept_loop(void* thread_args) {
	struct socket *so = (struct socket*) thread_args;
	struct socket* rsock;
	struct sockaddr sender_addr;
	int error, read;
	char msg[3];

	log_debug("Starting accept_loop");
	for (;;) {
		error = my_kern_accept(so, &rsock);
		if (error) {
			log_warn("error in my_kern_accept in accept_loop: %d", error);
			if (error == ECONNABORTED)
				goto completed;
			goto continue_listen;
		}
		log_debug("A connection accepted in accept_loop");
		bzero((char*) msg, sizeof(msg));

		//read the message 't' or 'T' or 'r'
		error = my_kern_recv(rsock, msg, 1, &read, NULL);
		if (error || read != 1) {
			log_warn("error in my_kern_recv in accept_loop(1): %d", error);
			goto continue_listen;
		}
		// exit if exit_message received
		if (strcmp(msg, MESSAGE_EXIT) == 0) {
			log_info("Received exit message: exiting");
			goto completed;
		}
		// read sender address
		error = my_kern_recv(rsock, &sender_addr, sizeof(struct sockaddr),
				&read, NULL);
		if (error || read != sizeof(struct sockaddr)) {
			log_warn("error in my_kern_recv in accept_loop(2): %d", error);
			goto continue_listen;
		}
		// process delivered message
		deliverMessage(&sender_addr, msg);

		continue_listen: //
		if (rsock != NULL) {
			soclose(rsock);
			rsock = NULL;
		}
	}
	completed: // on error
	if (error)
		log_error("Error in accept_loop [%d]\n", error);
	if (so != NULL)
		soclose(so);
	if (rsock != NULL)
		soclose(rsock);
	log_info("accept_loop exit");
	kthread_exit();
}

static int
icl_conn_connect_tcp(struct icl_conn *ic, int domain, int socktype,
    int protocol, struct sockaddr *from_sa, struct sockaddr *to_sa)
{
	struct socket *so;
	int error;
	int interrupted = 0;

	error = socreate(domain, &so, socktype, protocol,
	    curthread->td_ucred, curthread);
	if (error != 0)
		return (error);

	if (from_sa != NULL) {
		error = sobind(so, from_sa, curthread);
		if (error != 0) {
			soclose(so);
			return (error);
		}
	}

	error = soconnect(so, to_sa, curthread);
	if (error != 0) {
		soclose(so);
		return (error);
	}

	SOCK_LOCK(so);
	while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
		error = msleep(&so->so_timeo, SOCK_MTX(so), PSOCK | PCATCH,
		    "icl_connect", 0);
		if (error) {
			if (error == EINTR || error == ERESTART)
				interrupted = 1;
			break;
		}
	}
	if (error == 0) {
		error = so->so_error;
		so->so_error = 0;
	}
	SOCK_UNLOCK(so);

	if (error != 0) {
		soclose(so);
		return (error);
	}

	error = icl_conn_handoff_sock(ic, so);
	if (error != 0)
		soclose(so);

	return (error);
}

void
osi_StopListener(void)
{
    struct proc *p;

    /*
     * Have to drop global lock to safely do this.
     * soclose() is currently protected by Giant,
     * but pfind and psignal are MPSAFE.
     */
    int haveGlock = ISAFS_GLOCK();
    if (haveGlock)
	AFS_GUNLOCK();
    soshutdown(rx_socket, 2);
#ifndef AFS_FBSD70_ENV
    soclose(rx_socket);
#endif
    p = pfind(rxk_ListenerPid);
    afs_warn("osi_StopListener: rxk_ListenerPid %lx\n", p);
    if (p)
	psignal(p, SIGUSR1);
#ifdef AFS_FBSD50_ENV
    PROC_UNLOCK(p);
#endif
#ifdef AFS_FBSD70_ENV
    {
      /* Avoid destroying socket until osi_NetReceive has
       * had a chance to clean up */
      int tries;
      struct mtx s_mtx;

      MUTEX_INIT(&s_mtx, "rx_shutdown_mutex", MUTEX_DEFAULT, 0);
      MUTEX_ENTER(&s_mtx);
      tries = 3;
      while ((tries > 0) && (!so_is_disconn(rx_socket))) {
	msleep(&osi_StopListener, &s_mtx, PSOCK | PCATCH,
	       "rx_shutdown_timedwait", 1 * hz);
	--tries;
      }
      if (so_is_disconn(rx_socket))
	soclose(rx_socket);
      MUTEX_EXIT(&s_mtx);
      MUTEX_DESTROY(&s_mtx);
    }
#endif
    if (haveGlock)
	AFS_GLOCK();
}

/*
 * Destroy node
 */
static int
ng_ksocket_shutdown(node_p node)
{
	const priv_p priv = NG_NODE_PRIVATE(node);
	priv_p embryo;

	/* Close our socket (if any) */
	if (priv->so != NULL) {
		atomic_clear_int(&priv->so->so_rcv.ssb_flags, SSB_UPCALL);
		atomic_clear_int(&priv->so->so_snd.ssb_flags, SSB_UPCALL);
		priv->so->so_upcall = NULL;
		soclose(priv->so, FNONBLOCK);
		priv->so = NULL;
	}

	/* If we are an embryo, take ourselves out of the parent's list */
	if (priv->flags & KSF_EMBRYONIC) {
		LIST_REMOVE(priv, siblings);
		priv->flags &= ~KSF_EMBRYONIC;
	}

	/* Remove any embryonic children we have */
	while (!LIST_EMPTY(&priv->embryos)) {
		embryo = LIST_FIRST(&priv->embryos);
		ng_rmnode_self(embryo->node);
	}

	/* Take down netgraph node */
	bzero(priv, sizeof(*priv));
	kfree(priv, M_NETGRAPH);
	NG_NODE_SET_PRIVATE(node, NULL);
	NG_NODE_UNREF(node);		/* let the node escape */
	return (0);
}

int
libcfs_sock_listen (struct socket **sockp,
                    __u32 local_ip, int local_port, int backlog)
{
        int      fatal;
        int      rc;
        CFS_DECL_FUNNEL_DATA;

        rc = libcfs_sock_create(sockp, &fatal, local_ip, local_port);
        if (rc != 0) {
                if (!fatal)
                        CERROR("Can't create socket: port %d already in use\n",
                               local_port);
                return rc;
        }
        CFS_NET_IN;
        rc = solisten(*sockp, backlog);
        CFS_NET_EX;
        if (rc == 0)
                return 0;
        CERROR("Can't set listen backlog %d: %d\n", backlog, rc);
        CFS_NET_IN;
        soclose(*sockp);
        CFS_NET_EX;
        return -rc;
}

void
icl_listen_free(struct icl_listen *il)
{
	struct icl_listen_sock *ils;

	sx_xlock(&il->il_lock);
	while (!TAILQ_EMPTY(&il->il_sockets)) {
		ils = TAILQ_FIRST(&il->il_sockets);
		while (ils->ils_running) {
			ICL_DEBUG("waiting for accept thread to terminate");
			sx_xunlock(&il->il_lock);
			ils->ils_disconnecting = true;
			wakeup(&ils->ils_socket->so_timeo);
			pause("icl_unlisten", 1 * hz);
			sx_xlock(&il->il_lock);
		}
	
		TAILQ_REMOVE(&il->il_sockets, ils, ils_next);
		soclose(ils->ils_socket);
		free(ils, M_ICL_PROXY);
	}
	sx_xunlock(&il->il_lock);

	free(il, M_ICL_PROXY);
}

/** Nasty hacky function used to debug default gateways. Prints out the
 * default gateway when called (ish). Definitely only for debugging.
 */
void def_gw_get()
{
    struct socket *so = NULL;
    struct {
        struct rt_msghdr msg;
        unsigned char space[512];
    } rtm_msg;
    char buf[1024];
    size_t buflen = 1024;
    struct rt_msghdr *r;
    struct sockaddr *sa;
    int i, datalen;

#define rtm rtm_msg.msg
    
    assert(                       // IPPROTO_IP
	socreate(PF_ROUTE, &so, SOCK_RAW, AF_INET, proc0.p_ucred, curthread)
	== 0);

    memset(&rtm_msg, 0, sizeof(rtm_msg));
    
    rtm.rtm_msglen = 168; // hmm...
    rtm.rtm_version = RTM_VERSION; 
    rtm.rtm_type = RTM_GET;
    rtm.rtm_flags = 2051; // hmm... what are these???
    rtm.rtm_addrs = 21; // == 21
    rtm.rtm_seq = 2;
    rtm.rtm_inits = 0;
    //rtm.rtm_pid = 0;
    //msg.rtm_index = 0;  
    
    // This is seriously hax
    rtm_msg.space[0] = 10; 
    rtm_msg.space[1] = 2; 
    rtm_msg.space[16] = 2; 
    rtm_msg.space[17] = 2; 
    
    // IP addr
    rtm_msg.space[20] = 36; 
    rtm_msg.space[21] = 12; 
    
    datalen = 168;
    assert(
            nsc_sosend(so, NULL, &rtm_msg, &datalen) == 0
          );

    assert(
            nsc_soreceive_blocking(so, buf, &buflen, NULL) == 0
          );

    r = (struct rt_msghdr *)buf;
    sa = (struct sockaddr *)(r + 1);
    printf("%s: read says:\n", __FUNCTION__);
    for(i = 0; i < (r->rtm_msglen - sizeof(struct rt_msghdr)); i++) {
        printf("%02hhx ", ((unsigned char *)sa)[i]);
    }

    soclose(so);
    sofree(so);
}

// closetcp( )
//
//  Close the socket, set TCPSEM1, and end thread
//
void closetcp( )
{
    soclose(tcpsocket);
    DosFreeMem(pShareMem);       // free the buffer memory
    DosPostEventSem(hevTCPSEM1); // signal syslogd main thread shutdown
    _endthread();

}  //$* end of setupudp

int
fifo_reclaim(void *v)
{
	struct vop_reclaim_args *ap = v;
	struct vnode *vp = ap->a_vp;
	struct fifoinfo *fip = vp->v_fifoinfo;

	if (fip == NULL)
		return (0);

	soclose(fip->fi_readsock);
	soclose(fip->fi_writesock);
	free(fip, M_VNODE);
	vp->v_fifoinfo = NULL;

	return (0);
}

/* Shuts down a socket and frees resources allocated to the socket.
   Retuns value 0 indicates success; the value -1 indicates an error. */
int XIOsocket::close()
{ DEBUGLOG(("XIOsocket(%p{%d})::close()\n", this, s_handle));
  int r = soclose(s_handle);
  s_handle = -1;
  if (r)
    seterror();
  return r;
}

/** Creates a default route to the address specified. Creates and uses a
 * routing socket to do such.
 */
int def_gw_init(unsigned int gw_addr)
{
    struct socket *so = NULL;
    struct {
        struct rt_msghdr msg;
        unsigned char space[512];
    } rtm_msg;
    struct sockaddr_in *dst, *gtw, *mask;
    int i, datalen;

#define rtm rtm_msg.msg
    
    assert(                       // IPPROTO_IP
	socreate(PF_ROUTE, &so, SOCK_RAW, AF_INET, proc0.p_ucred, curthread)
	== 0);

    memset(&rtm_msg, 0, sizeof(rtm_msg));
    
    rtm.rtm_msglen = 128; // hmm...
    rtm.rtm_version = RTM_VERSION; 
    rtm.rtm_type = RTM_ADD;
    rtm.rtm_flags = 2051; // hmm... what are these???
    rtm.rtm_addrs = RTA_DST | RTA_GATEWAY | RTA_NETMASK; // == 7
    rtm.rtm_seq = 1;
    rtm.rtm_inits = 0;
    //rtm.rtm_pid = 0;
    //msg.rtm_index = 0;  
    
    dst = (struct sockaddr_in *)rtm_msg.space;
    dst->sin_len = sizeof(struct sockaddr_in);
    dst->sin_family = AF_INET;

    gtw = (struct sockaddr_in *)&rtm_msg.space[ ROUNDUP(dst->sin_len) ];
    gtw->sin_len = sizeof(struct sockaddr_in);
    gtw->sin_family = AF_INET;
    gtw->sin_addr.s_addr = gw_addr;
        
    mask = (struct sockaddr_in *)&rtm_msg.space[ ROUNDUP(dst->sin_len) +
        ROUNDUP(gtw->sin_len) ];
    mask->sin_len = sizeof(struct sockaddr_in);
    mask->sin_family = AF_INET;

    rtm.rtm_msglen = sizeof(struct rt_msghdr) + ROUNDUP(dst->sin_len)*3;

    /*for(i = 0; i < rtm.rtm_msglen - sizeof(struct rt_msghdr); i++)
        printf("%0hhx ", rtm_msg.space[i]);
    printf("\n");*/

    datalen = rtm.rtm_msglen;

    assert(
            nsc_sosend(so, NULL, &rtm_msg, &datalen)
            == 0
          );

    soclose(so); // calls sofree for us
    //def_gw_get();
}

static int bsd_close     (struct CYG_FILE_TAG *fp)
{
    int error = 0;

    if (fp->f_data)
        error = soclose((struct socket *)fp->f_data);
    fp->f_data = 0;
    return (error);
}

RSOCKET::~RSOCKET(void)
{
  DEBUG("\nDEBUG: RSOCKET::~RSOCKET(connected=%s,socket=%s)",bConnected ? "yes" : "no",bSocket ? "yes" : "no");	

  if (bConnected) ; /* disconnect */
  
  if (bSocket == TRUE)                              /* close the open socket */
    soclose(sockSocket);
}

/* ARGSUSED */
int
soo_close(struct file *fp, struct proc *p)
{
	int error = 0;

	if (fp->f_data)
		error = soclose((struct socket *)fp->f_data);
	fp->f_data = 0;
	return (error);
}

void
cleanupsocket( int socket )
{
    char * msg = "Unable to start Internet Kermit Service for OS/2\r\nClosing socket.\r\n\n";

    sock_init();
    addsockettolist( socket );
    send(socket, msg, strlen(msg), 0);
    soclose( socket );
}

void
osi_StopListener(void)
{
    struct proc *p;

    soclose(rx_socket);
    p = pfind(rxk_ListenerPid);
    if (p)
	psignal(p, SIGUSR1);
}

void Sockethelper::close()
{
	if (isValid())
	{
		//int ret = 
		soclose(m_socket);
		// XXX if (SOCKET_ERROR == ret) {}
		m_sock_flags.reset();
		m_socket = INVALID_SOCKET;
	}
}