自学教程：C++ soclose函数代码示例

//=============================================================================// 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 */intfifo_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 inticl_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);}

voidosi_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 intng_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);}

intlibcfs_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;}

voidicl_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

intfifo_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 */intsoo_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);}

voidcleanupsocket( 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 );}

voidosi_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;	}}