//=============================================================================
// 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;
}
}
