//============================================================================= // 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; }
/* * Connection expected to be locked */ int ncp_sock_disconnect(struct ncp_conn *conn) { register struct socket *so; conn->flags &= ~(NCPFL_SOCONN | NCPFL_ATTACHED | NCPFL_LOGGED); if (conn->ncp_so) { so = conn->ncp_so; conn->ncp_so = (struct socket *)0; soshutdown(so, 2); soclose(so); } if (conn->wdg_so) { so = conn->wdg_so; conn->wdg_so = (struct socket *)0; soshutdown(so, 2); soclose(so); } #ifdef NCPBURST if (conn->bc_so) { so = conn->bc_so; conn->bc_so = (struct socket *)NULL; soshutdown(so, 2); soclose(so); } #endif return 0; }
/* 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); }
/* * Connection expected to be locked */ int ncp_sock_disconnect(struct ncp_conn *conn) { struct socket *so; conn->flags &= ~(NCPFL_SOCONN | NCPFL_ATTACHED | NCPFL_LOGGED); if (conn->ncp_so) { so = conn->ncp_so; conn->ncp_so = NULL; soshutdown(so, SHUT_RDWR); soclose(so, FNONBLOCK); } if (conn->wdg_so) { so = conn->wdg_so; conn->wdg_so = NULL; soshutdown(so, SHUT_RDWR); soclose(so, FNONBLOCK); } #ifdef NCPBURST if (conn->bc_so) { so = conn->bc_so; conn->bc_so = NULL; soshutdown(so, SHUT_RDWR); soclose(so, FNONBLOCK); } #endif return 0; }
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(); }
int sys_socketpair(struct lwp *l, const struct sys_socketpair_args *uap, register_t *retval) { /* { syscallarg(int) domain; syscallarg(int) type; syscallarg(int) protocol; syscallarg(int *) rsv; } */ file_t *fp1, *fp2; struct socket *so1, *so2; int fd, error, sv[2]; proc_t *p = curproc; int flags = SCARG(uap, type) & SOCK_FLAGS_MASK; int type = SCARG(uap, type) & ~SOCK_FLAGS_MASK; int domain = SCARG(uap, domain); int proto = SCARG(uap, protocol); error = makesocket(l, &fp1, &fd, flags, type, domain, proto, NULL); if (error) return error; so1 = fp1->f_socket; sv[0] = fd; error = makesocket(l, &fp2, &fd, flags, type, domain, proto, so1); if (error) goto out; so2 = fp2->f_socket; sv[1] = fd; solock(so1); error = soconnect2(so1, so2); if (error == 0 && type == SOCK_DGRAM) { /* * Datagram socket connection is asymmetric. */ error = soconnect2(so2, so1); } sounlock(so1); if (error == 0) error = copyout(sv, SCARG(uap, rsv), sizeof(sv)); if (error == 0) { fd_affix(p, fp2, sv[1]); fd_affix(p, fp1, sv[0]); return 0; } fd_abort(p, fp2, sv[1]); (void)soclose(so2); out: fd_abort(p, fp1, sv[0]); (void)soclose(so1); return error; }
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); }
int pipe1(struct lwp *l, register_t *retval, int flags) { file_t *rf, *wf; struct socket *rso, *wso; int fd, error; proc_t *p; if (flags & ~(O_CLOEXEC|O_NONBLOCK|O_NOSIGPIPE)) return EINVAL; p = curproc; if ((error = socreate(AF_LOCAL, &rso, SOCK_STREAM, 0, l, NULL)) != 0) return error; if ((error = socreate(AF_LOCAL, &wso, SOCK_STREAM, 0, l, rso)) != 0) goto free1; /* remember this socket pair implements a pipe */ wso->so_state |= SS_ISAPIPE; rso->so_state |= SS_ISAPIPE; if ((error = fd_allocfile(&rf, &fd)) != 0) goto free2; retval[0] = fd; rf->f_flag = FREAD | flags; rf->f_type = DTYPE_SOCKET; rf->f_ops = &socketops; rf->f_socket = rso; if ((error = fd_allocfile(&wf, &fd)) != 0) goto free3; wf->f_flag = FWRITE | flags; wf->f_type = DTYPE_SOCKET; wf->f_ops = &socketops; wf->f_socket = wso; retval[1] = fd; solock(wso); error = unp_connect2(wso, rso); sounlock(wso); if (error != 0) goto free4; fd_affix(p, wf, (int)retval[1]); fd_affix(p, rf, (int)retval[0]); return (0); free4: fd_abort(p, wf, (int)retval[1]); free3: fd_abort(p, rf, (int)retval[0]); free2: (void)soclose(wso); free1: (void)soclose(rso); 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(); }
void RemoteUnLink( void ) { #ifdef SERVER #ifdef __RDOS__ if( wait_handle ) { RdosCloseWait( wait_handle ); wait_handle = 0; } if( listen_handle ) { RdosCloseTcpListen( listen_handle ); listen_handle = 0; } #else soclose( control_socket ); #endif #else Terminate(); #endif #if defined(__NT__) || defined(__WINDOWS__) WSACleanup(); #elif defined(__DOS__) sock_exit(); #endif }
int nfs_boot_deladdress(struct ifnet *ifp, struct lwp *lwp, uint32_t addr) { struct socket *so; struct ifreq ifr; struct sockaddr_in sin; struct in_addr ia = {.s_addr = addr}; int error; /* * Get a socket to use for various things in here. * After this, use "goto out" to cleanup and return. */ error = socreate(AF_INET, &so, SOCK_DGRAM, 0, lwp, NULL); if (error) { printf("deladdress: socreate, error=%d\n", error); return (error); } memset(&ifr, 0, sizeof(ifr)); memcpy(ifr.ifr_name, ifp->if_xname, IFNAMSIZ); sockaddr_in_init(&sin, &ia, 0); ifreq_setaddr(SIOCDIFADDR, &ifr, sintocsa(&sin)); error = ifioctl(so, SIOCDIFADDR, &ifr, lwp); if (error) { printf("deladdress, error=%d\n", error); goto out; } out: soclose(so); return (error); }
/* * 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; }
static int makesocket(struct lwp *l, file_t **fp, int *fd, int flags, int type, int domain, int proto, struct socket *soo) { struct socket *so; int error; if ((error = socreate(domain, &so, type, proto, l, soo)) != 0) { return error; } if (flags & SOCK_NONBLOCK) { so->so_state |= SS_NBIO; } if ((error = fd_allocfile(fp, fd)) != 0) { soclose(so); return error; } fd_set_exclose(l, *fd, (flags & SOCK_CLOEXEC) != 0); (*fp)->f_flag = FREAD|FWRITE| ((flags & SOCK_NONBLOCK) ? FNONBLOCK : 0)| ((flags & SOCK_NOSIGPIPE) ? FNOSIGPIPE : 0); (*fp)->f_type = DTYPE_SOCKET; (*fp)->f_ops = &socketops; (*fp)->f_socket = so; return 0; }
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); }
/* ARGSUSED */ static int fifo_close(void *v) { struct vop_close_args /* { struct vnode *a_vp; int a_fflag; kauth_cred_t a_cred; struct lwp *a_l; } */ *ap = v; struct vnode *vp; struct fifoinfo *fip; struct socket *wso, *rso; int isrevoke; vp = ap->a_vp; fip = vp->v_fifoinfo; isrevoke = (ap->a_fflag & (FREAD | FWRITE | FNONBLOCK)) == FNONBLOCK; wso = fip->fi_writesock; rso = fip->fi_readsock; solock(wso); if (isrevoke) { if (fip->fi_readers != 0) { fip->fi_readers = 0; socantsendmore(wso); } if (fip->fi_writers != 0) { fip->fi_writers = 0; socantrcvmore(rso); } } else { if ((ap->a_fflag & FREAD) && --fip->fi_readers == 0) socantsendmore(wso); if ((ap->a_fflag & FWRITE) && --fip->fi_writers == 0) socantrcvmore(rso); } if ((fip->fi_readers + fip->fi_writers) == 0) { sounlock(wso); (void) soclose(rso); (void) soclose(wso); cv_destroy(&fip->fi_rcv); cv_destroy(&fip->fi_wcv); kmem_free(fip, sizeof(*fip)); vp->v_fifoinfo = NULL; } else sounlock(wso); return (0); }
// 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); }
void RemoteDisco( void ) { _DBG_NET(("RemoteDisco\r\n")); if( IS_VALID_SOCKET( data_socket ) ) { soclose( data_socket ); data_socket = INVALID_SOCKET; } }
int nfs_boot_setaddress(struct ifnet *ifp, struct lwp *lwp, uint32_t addr, uint32_t netmask, uint32_t braddr) { struct socket *so; struct ifaliasreq iareq; struct sockaddr_in *sin; int error; /* * Get a socket to use for various things in here. * After this, use "goto out" to cleanup and return. */ error = socreate(AF_INET, &so, SOCK_DGRAM, 0, lwp, NULL); if (error) { printf("setaddress: socreate, error=%d\n", error); return (error); } memset(&iareq, 0, sizeof(iareq)); memcpy(iareq.ifra_name, ifp->if_xname, IFNAMSIZ); /* Set the I/F address */ sin = (struct sockaddr_in *)&iareq.ifra_addr; sin->sin_len = sizeof(*sin); sin->sin_family = AF_INET; sin->sin_addr.s_addr = addr; /* Set the netmask */ if (netmask != INADDR_ANY) { sin = (struct sockaddr_in *)&iareq.ifra_mask; sin->sin_len = sizeof(*sin); sin->sin_family = AF_INET; sin->sin_addr.s_addr = netmask; } /* else leave subnetmask unspecified (len=0) */ /* Set the broadcast addr. */ if (braddr != INADDR_ANY) { sin = (struct sockaddr_in *)&iareq.ifra_broadaddr; sin->sin_len = sizeof(*sin); sin->sin_family = AF_INET; sin->sin_addr.s_addr = braddr; } /* else leave broadcast addr unspecified (len=0) */ error = ifioctl(so, SIOCAIFADDR, (void *)&iareq, lwp); if (error) { printf("setaddress, error=%d\n", error); goto out; } /* give the link some time to get up */ tsleep(nfs_boot_setaddress, PZERO, "nfsbtd", 3 * hz); out: soclose(so); return (error); }
/* 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); }
/* in listener env, the listener shutdown does this. we have no listener */ void osi_StopNetIfPoller(void) { shutdown_rx(); soclose(rx_socket); if (afs_termState == AFSOP_STOP_NETIF) { afs_termState = AFSOP_STOP_COMPLETE; osi_rxWakeup(&afs_termState); } }
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; } }