/*----------------------------------------------------------------------* rtp_net_gethostbyname *----------------------------------------------------------------------*/ int rtp_net_gethostbyname (unsigned char *ipAddr, int *type, char *name) { #if (INCLUDE_DNS) #ifdef RTP_DEBUG int result; #endif PFHOSTENT hp = NULL; #ifdef RTP_DEBUG /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif if (!(hp = gethostbyname(name))) { #ifdef RTP_DEBUG result = xn_getlasterror(); RTP_DEBUG_OUTPUT_STR("rtp_net_gethostbyname: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } if (hp->h_addrtype != AF_INET) { #ifdef RTP_DEBUG set_errno (EAFNOSUPPORT); result = xn_getlasterror(); RTP_DEBUG_OUTPUT_STR("rtp_net_gethostbyname: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } *type = RTP_NET_TYPE_IPV4; ipAddr[0] = (unsigned char) hp->h_addr_list[0][0]; ipAddr[1] = (unsigned char) hp->h_addr_list[0][1]; ipAddr[2] = (unsigned char) hp->h_addr_list[0][2]; ipAddr[3] = (unsigned char) hp->h_addr_list[0][3]; return (0); #else rtp_not_yet_implemented(); return (-1); #endif /* INCLUDE_DNS */ }
/*----------------------------------------------------------------------* rtp_net_setmcastttl *----------------------------------------------------------------------*/ int rtp_net_setmcastttl(RTP_HANDLE sockHandle, int ttl) { int result; #ifdef RTP_DEBUG /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif result = setsockopt( sockHandle, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &ttl, sizeof (int)); if (result != 0) { #ifdef RTP_DEBUG result = xn_getlasterror(); RTP_DEBUG_OUTPUT_STR("rtp_net_setmcastttl: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (0); }
/*----------------------------------------------------------------------* rtp_net_setkeepalive *----------------------------------------------------------------------*/ int rtp_net_setkeepalive (RTP_HANDLE sockHandle, unsigned int onBool) { #ifdef RTP_DEBUG int result; /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif if (setsockopt((int) sockHandle, SOL_SOCKET, SO_KEEPALIVE, (PFCCHAR)&onBool, sizeof (int)) != 0) { #ifdef RTP_DEBUG result = xn_getlasterror(); RTP_DEBUG_OUTPUT_STR("rtp_net_setkeepalive: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (0); }
/*----------------------------------------------------------------------* rtp_net_setblocking *----------------------------------------------------------------------*/ int rtp_net_setblocking (RTP_HANDLE sockHandle, unsigned int onBool) { unsigned long arg; #ifdef RTP_DEBUG int result; /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif arg = (unsigned long)(!onBool); if (ioctlsocket((int) sockHandle, FIONBIO, &arg) != 0) { #ifdef RTP_DEBUG result = xn_getlasterror(); RTP_DEBUG_OUTPUT_STR("rtp_net_setblocking: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (0); }
/*----------------------------------------------------------------------* rtp_file_open *----------------------------------------------------------------------*/ int rtp_file_open (RTP_HANDLE * fdPtr, const char * name, unsigned short flag, unsigned short mode) { long fileHandle; #ifdef RTP_DEBUG int result; /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif name = (char *) _rtp_name_to_nativename((char *) name); fileHandle = (long) vf_open((PFCHAR) name, (word) _rtp_flag_to_operation(flag), (word) _rtp_mode_to_permission(mode)); if (fileHandle == (-1)) { #ifdef RTP_DEBUG result = xn_getlasterror( ); RTP_DEBUG_OUTPUT_STR("rtp_file_open: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } *fdPtr = (RTP_HANDLE) fileHandle; return (0); }
/*----------------------------------------------------------------------* rtp_net_socket_stream *----------------------------------------------------------------------*/ int rtp_net_socket_stream (RTP_HANDLE *sockHandle) { int sock; #ifdef RTP_DEBUG int result; /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif sock = socket(AF_INET, SOCK_STREAM, 0); if (sock < 0) { *sockHandle = ((RTP_HANDLE)-1); #ifdef RTP_DEBUG result = xn_getlasterror(); RTP_DEBUG_OUTPUT_STR("rtp_net_socket_stream: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } *sockHandle = (RTP_HANDLE) sock; return (0); }
/*----------------------------------------------------------------------* rtp_net_getntoread *----------------------------------------------------------------------*/ int rtp_net_getntoread (RTP_HANDLE sockHandle, unsigned long * nToRead) { unsigned long arg; #ifdef RTP_DEBUG int result; /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif if (ioctlsocket((int) sockHandle, FIONREAD, &arg) != 0) { #ifdef RTP_DEBUG result = xn_getlasterror(); RTP_DEBUG_OUTPUT_STR("rtp_net_getntoread: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } *nToRead = arg; return (0); }
/*----------------------------------------------------------------------* rtp_file_rmdir *----------------------------------------------------------------------*/ int rtp_file_rmdir (char * name) { #ifdef RTP_DEBUG int result; /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif name = _rtp_name_to_nativename(name); if (!vf_rmdir((PFCHAR)name)) { #ifdef RTP_DEBUG result = xn_getlasterror( ); RTP_DEBUG_OUTPUT_STR("rtp_file_rmdir: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (0); }
/*----------------------------------------------------------------------* rtp_net_recv *----------------------------------------------------------------------*/ long rtp_net_recv (RTP_HANDLE sockHandle, unsigned char * buffer, long size) { long result; /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); result = (long) recv((int) sockHandle, (char *) buffer, (int) size, 0); if (result < 0) { result = (long) xn_getlasterror(); if ((result == EINPROGRESS) || (result == EWOULDBLOCK)) { RTP_DEBUG_OUTPUT_STR("rtp_net_recv: non-fatal error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); return (-2); } RTP_DEBUG_OUTPUT_STR("rtp_net_recv: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); return (-1); } return (result); }
/*----------------------------------------------------------------------* rtp_file_pwd *----------------------------------------------------------------------*/ int rtp_file_pwd (char * name, long size) { #ifdef RTP_DEBUG int result; /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif if (!vf_pwd(name)) { #ifdef RTP_DEBUG result = xn_getlasterror(); RTP_DEBUG_OUTPUT_STR("rtp_file_pwd: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } name = _rtp_nativename_to_name(name); return (0); }
/*----------------------------------------------------------------------* rtp_file_gfirst *----------------------------------------------------------------------*/ int rtp_file_gfirst (void ** dirobj, char * name) { VDSTAT* nativeDirObj; #ifdef RTP_DEBUG int result; /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif nativeDirObj = (VDSTAT*) rtp_malloc(sizeof(VDSTAT)); rtp_memset(nativeDirObj, 0, sizeof(VDSTAT)); if (!vf_gfirst(nativeDirObj, (PFCHAR) name)) { rtp_free(nativeDirObj); #ifdef RTP_DEBUG result = xn_getlasterror( ); RTP_DEBUG_OUTPUT_STR("rtp_file_gfirst: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } *dirobj = (void*) nativeDirObj; return (0); }
/*----------------------------------------------------------------------* rtp_file_chmode *----------------------------------------------------------------------*/ int rtp_file_chmode (char * name, unsigned char attributes) { int nativemode; #ifdef RTP_DEBUG int result; /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif nativemode = 0; nativemode |= (attributes & RTP_FILE_ATTRIB_RDONLY) ? VF_ATTRIB_RDONLY : 0; nativemode |= (attributes & RTP_FILE_ATTRIB_WRONLY) ? VF_ATTRIB_WRONLY : 0; nativemode |= (attributes & RTP_FILE_ATTRIB_RDWR) ? VF_ATTRIB_RDWR : 0; /* nativemode |= (attributes & RTP_FILE_ATTRIB_ARCHIVE) ? unsupported : 0; */ /* nativemode |= (attributes & RTP_FILE_ATTRIB_HIDDEN) ? unsupported : 0; */ /* nativemode |= (attributes & RTP_FILE_ATTRIB_SYSTEM) ? unsupported : 0; */ name = _rtp_name_to_nativename(name); if (!vf_chmode((PFCHAR) name, nativemode)) { #ifdef RTP_DEBUG result = xn_getlasterror( ); RTP_DEBUG_OUTPUT_STR("rtp_file_chmode: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (0); }
/*----------------------------------------------------------------------* rtp_file_get_free *----------------------------------------------------------------------*/ int rtp_file_get_free (char * name, unsigned long *total, unsigned long *free, unsigned long *sectors_per_unit, unsigned short *bytes_per_sector) { dword blocks; dword bfree; #ifdef RTP_DEBUG int result; /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif name = _rtp_name_to_nativename(name); if (!vf_get_free((PFCHAR) name, &blocks, &bfree)) { #ifdef RTP_DEBUG result = xn_getlasterror( ); RTP_DEBUG_OUTPUT_STR("rtp_file_get_free: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } *total = (unsigned long) &blocks; *free = (unsigned long) &bfree; *sectors_per_unit = (unsigned long) 0; /* [tbd] */ *bytes_per_sector = (unsigned short) 0; /* [tbd] */ return (0); }
/*----------------------------------------------------------------------* rtp_file_flush *----------------------------------------------------------------------*/ int rtp_file_flush (RTP_HANDLE fd) { #ifdef RTP_DEBUG int result; /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif /* ----------------------------------- */ /* trick to flush file */ /* ----------------------------------- */ if (!vf_flush(fd)) { #ifdef RTP_DEBUG result = xn_getlasterror( ); RTP_DEBUG_OUTPUT_STR("rtp_file_flush: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (0); }
static INLINE int LastError(void) { #ifdef USE_WINDOWS_API return WSAGetLastError(); #elif defined(EBSNET) return xn_getlasterror(); #else return errno; #endif }
/*----------------------------------------------------------------------* rtp_net_read_select *----------------------------------------------------------------------*/ int rtp_net_read_select (RTP_HANDLE sockHandle, long msecTimeout) { struct timeval selectTime; fd_set read_set; int result; /* ----------------------------------- */ /* read list */ /* ----------------------------------- */ FD_ZERO(&read_set); FD_SET(sockHandle, &read_set); #ifdef RTP_DEBUG /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif if (msecTimeout >= 0) { selectTime.tv_sec = msecTimeout / 1000; selectTime.tv_usec = (msecTimeout % 1000) * 1000; result = select(1, (PFDSET) &read_set, (PFDSET) 0, (PFDSET) 0, (PCTIMEVAL) &selectTime); } else { result = select(1, (PFDSET) &read_set, (PFDSET) 0, (PFDSET) 0, (PCTIMEVAL) NULL); } /* if (result == 1) | { | if (!xn_tcp_is_read(sockHandle)) | { | result = (-1); | } | } */ /* if an error or if it timed out */ if (result <= 0) { #ifdef RTP_DEBUG result = xn_getlasterror(); RTP_DEBUG_OUTPUT_STR("rtp_net_read_select: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (0); }
/*----------------------------------------------------------------------* rtp_net_recvfrom *----------------------------------------------------------------------*/ long rtp_net_recvfrom (RTP_HANDLE sockHandle, unsigned char *buffer, long size, unsigned char *ipAddr, int *port, int *type) { long result; int remoteLen; struct sockaddr_in remote; remoteLen = sizeof (remote); memset (&remote, 0, remoteLen); /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); result = (long) recvfrom ((int) sockHandle, (PFCHAR) buffer, (int) size, 0, (PSOCKADDR) &remote, (PFINT) &remoteLen); if (result < 0) { result = (long) xn_getlasterror(); if ((result == EINPROGRESS) || (result == EWOULDBLOCK)) { RTP_DEBUG_OUTPUT_STR("rtp_net_recvfrom: non-fatal error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); return (-2); } RTP_DEBUG_OUTPUT_STR("rtp_net_recvfrom: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); return (-1); } if (ipAddr) { unsigned long d = remote.sin_addr.s_addr; unsigned char *ptr = (unsigned char *) &d; ipAddr[0] = ptr[0]; ipAddr[1] = ptr[1]; ipAddr[2] = ptr[2]; ipAddr[3] = ptr[3]; *type = RTP_NET_TYPE_IPV4; *port = ntohs (remote.sin_port); } return (result); }
/*----------------------------------------------------------------------* rtp_net_getsockname *----------------------------------------------------------------------*/ int rtp_net_getsockname (RTP_HANDLE sockHandle, unsigned char *ipAddr, int *port, int *type) { struct sockaddr_in localAddr; int localLen; #ifdef RTP_DEBUG int result; #endif localLen = sizeof (localAddr); memset(&localAddr, 0, localLen); #ifdef RTP_DEBUG /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif if (getsockname ((int) sockHandle, (PSOCKADDR) &localAddr, (PFINT) &localLen) != 0) { #ifdef RTP_DEBUG result = xn_getlasterror(); RTP_DEBUG_OUTPUT_STR("rtp_net_getsockname: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } if (ipAddr) { unsigned long d = localAddr.sin_addr.s_addr; unsigned char *ptr = (unsigned char *) &d; *type = RTP_NET_TYPE_IPV4; ipAddr[0] = ptr[0]; ipAddr[1] = ptr[1]; ipAddr[2] = ptr[2]; ipAddr[3] = ptr[3]; } if (port) { *port = ntohs (localAddr.sin_port); } return (0); }
/*----------------------------------------------------------------------* rtp_file_lseek *----------------------------------------------------------------------*/ long rtp_file_lseek (RTP_HANDLE fd, long offset, int origin) { long result; int relative_to; #ifdef RTP_DEBUG /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif switch (origin) { case 0: relative_to = VSEEK_SET; break; case 1: relative_to = VSEEK_CUR; break; case 2: relative_to = VSEEK_END; break; default: #ifdef RTP_DEBUG RTP_DEBUG_OUTPUT_STR("rtp_file_lseek: error returned.\n"); #endif return (-1); break; } if ((result = vf_lseek((int) fd, offset, relative_to)) < 0) { #ifdef RTP_DEBUG result = xn_getlasterror( ); RTP_DEBUG_OUTPUT_STR("rtp_file_lseek: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (result); }
/**************************************************** * Initialize socket for RTIP ****************************************************/ int SOCK_Init (void) { int iface; byte tnet_localHost[4] = {192, 168, 1, 43}; byte tnet_maskip[4] = {255, 255, 255, 0}; PRINTF (("about to init xn_rtip\n")); /* px_init (); */ if(xn_rtip_init()!=0) { PRINTF (("SOCK_Init: Error in xn_rtip_init\n")); return -1; } PRINTF (("about to open xn_interface config\n")); /* packard bell */ /* iface = xn_interface_open_config (NE2000_DEVICE, MINOR_0, 0x220, 10, 0); */ /* IntelliStation */ /* iface = xn_interface_open_config (I82559_DEVICE, MINOR_0, 0x78e0, 8, 0xf000); */ /* Toshiba */ iface = xn_interface_open_config (CE3_PCMCIA_DEVICE, MINOR_0, 0x110, 10, 0); if(iface < 0) { PRINTF (("SOCK_Init: Interface Open Failed - returned %s\n", xn_geterror_string (xn_getlasterror ()))); return -1; } PRINTF (("about to set ip\n")); if(xn_set_ip(iface, tnet_localHost, tnet_maskip)) { PRINTF (("SOCK_Init: xn_set_ip error\n")); return -1; } rtsmb_srv_init (tnet_localHost, tnet_maskip, NULL, NULL); rtsmb_cli_init (tnet_localHost, tnet_maskip); return 0; }
/*----------------------------------------------------------------------* rtp_net_setlinger *----------------------------------------------------------------------*/ int rtp_net_setlinger (RTP_HANDLE sockHandle, unsigned int onBool, long msecTimeout) { LINGER arg; #ifdef RTP_DEBUG int result; #endif arg.l_onoff = onBool; arg.l_linger = 0; if (arg.l_onoff) { if (msecTimeout > 0) { arg.l_linger = (int) (msecTimeout / 1000); } } #ifdef RTP_DEBUG /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif if (setsockopt((int) sockHandle, SOL_SOCKET, SO_LINGER, (PFCCHAR) &arg, sizeof (struct linger)) != 0) { #ifdef RTP_DEBUG result = xn_getlasterror(); RTP_DEBUG_OUTPUT_STR("rtp_net_setlinger: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (0); }
/*----------------------------------------------------------------------* rtp_net_shutdown *----------------------------------------------------------------------*/ int rtp_net_shutdown (RTP_HANDLE sockHandle, int how) { #ifdef RTP_DEBUG int result; /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif if (shutdown((int) sockHandle, how) != 0) { #ifdef RTP_DEBUG result = xn_getlasterror(); RTP_DEBUG_OUTPUT_STR("rtp_net_shutdown: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (0); }
/*----------------------------------------------------------------------* rtp_file_truncate *----------------------------------------------------------------------*/ int rtp_file_truncate (RTP_HANDLE fd, long offset) { #ifdef RTP_DEBUG int result; /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif if (!vf_truncate((int) fd, offset)) { #ifdef RTP_DEBUG result = xn_getlasterror( ); RTP_DEBUG_OUTPUT_STR("rtp_file_truncate: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (0); }
/*----------------------------------------------------------------------* rtp_file_close *----------------------------------------------------------------------*/ int rtp_file_close (RTP_HANDLE fileHandle) { #ifdef RTP_DEBUG int result; /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif if (vf_close((int) fileHandle) != 0) { #ifdef RTP_DEBUG result = xn_getlasterror( ); RTP_DEBUG_OUTPUT_STR("rtp_file_close: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (0); }
/*----------------------------------------------------------------------* rtp_file_gnext *----------------------------------------------------------------------*/ int rtp_file_gnext (void * dirobj) { #ifdef RTP_DEBUG int result; /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif if (!vf_gnext((VDSTAT*) dirobj)) { #ifdef RTP_DEBUG result = xn_getlasterror( ); RTP_DEBUG_OUTPUT_STR("rtp_file_gnext: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (0); }
/*----------------------------------------------------------------------* rtp_file_write *----------------------------------------------------------------------*/ long rtp_file_write (RTP_HANDLE fileHandle, const unsigned char * buffer, long count) { int result; #ifdef RTP_DEBUG /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); #endif if ((result = vf_write((int) fileHandle, (PFBYTE) buffer, (word) count)) < 0) { #ifdef RTP_DEBUG result = xn_getlasterror( ); RTP_DEBUG_OUTPUT_STR("rtp_file_write: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (result); }
/*----------------------------------------------------------------------* rtp_net_accept *----------------------------------------------------------------------*/ int rtp_net_accept (RTP_HANDLE *connectSock, RTP_HANDLE serverSock, unsigned char *ipAddr, int *port, int *type) { struct sockaddr_in clientAddr; int clientLen; int conSocket; int result; clientLen = sizeof (clientAddr); memset(&clientAddr, 0, clientLen); /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); conSocket = accept ((int) serverSock, (PSOCKADDR) &clientAddr, (PFINT) &clientLen); if (conSocket < 0) { *connectSock = ((RTP_HANDLE)-1); result = xn_getlasterror(); if ((result == EINPROGRESS) || (result == EWOULDBLOCK)) { #ifdef RTP_DEBUG RTP_DEBUG_OUTPUT_STR("rtp_net_accept: non-fatal error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-2); } #ifdef RTP_DEBUG RTP_DEBUG_OUTPUT_STR("rtp_net_accept: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } *connectSock = (RTP_HANDLE)conSocket; if (ipAddr) { unsigned long d = clientAddr.sin_addr.s_addr; unsigned char *ptr = (unsigned char *) &d; *type = RTP_NET_TYPE_IPV4; ipAddr[0] = ptr[0]; ipAddr[1] = ptr[1]; ipAddr[2] = ptr[2]; ipAddr[3] = ptr[3]; } if (port) { *port = ntohs (clientAddr.sin_port); } return (0); }
/*----------------------------------------------------------------------* rtp_net_connect *----------------------------------------------------------------------*/ int rtp_net_connect (RTP_HANDLE sockHandle, unsigned char *ipAddr, int port, int type) { int result; int sinLen; struct sockaddr_in sin; unsigned long in_addr = 0; sinLen = sizeof (sin); memset(&sin, 0, sinLen); if (ipAddr) { unsigned char *ptr = (unsigned char *) &in_addr; if (type != RTP_NET_TYPE_IPV4) { return (-1); } ptr[0] = ipAddr[0]; ptr[1] = ipAddr[1]; ptr[2] = ipAddr[2]; ptr[3] = ipAddr[3]; } else { /* invalid address */ return (-1); } sin.sin_family = AF_INET; sin.sin_addr.s_addr = in_addr; sin.sin_port = htons((unsigned short)port); /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); if (connect ((int) sockHandle, (PSOCKADDR) &sin, sinLen) != 0) { result = xn_getlasterror(); if ((result == EINPROGRESS) || (result == EWOULDBLOCK)) { #ifdef RTP_DEBUG RTP_DEBUG_OUTPUT_STR("rtp_net_connect: non-fatal error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-2); } #ifdef RTP_DEBUG RTP_DEBUG_OUTPUT_STR("rtp_net_connect: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } return (0); }
/*----------------------------------------------------------------------* rtp_net_sendto *----------------------------------------------------------------------*/ long rtp_net_sendto (RTP_HANDLE sockHandle, const unsigned char * buffer, long size, unsigned char * ipAddr, int port, int type) { long result; int sinLen; struct sockaddr_in sin; unsigned long in_addr = 0; sinLen = sizeof (sin); memset(&sin, 0, sinLen); if (ipAddr) { unsigned char *ptr = (unsigned char *) &in_addr; if (type != RTP_NET_TYPE_IPV4) { return (-1); } ptr[0] = ipAddr[0]; ptr[1] = ipAddr[1]; ptr[2] = ipAddr[2]; ptr[3] = ipAddr[3]; } else { /* invalid address */ return (-1); } sin.sin_family = AF_INET; sin.sin_addr.s_addr = in_addr; sin.sin_port = htons((unsigned short)port); /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); result = (long) sendto((int) sockHandle, (PFCCHAR) buffer, (int) size, 0, (PCSOCKADDR)&sin, sinLen); if (result < 0) { result = (long) xn_getlasterror(); if ((result == EINPROGRESS) || (result == EWOULDBLOCK)) { RTP_DEBUG_OUTPUT_STR("rtp_net_sendto: non-fatal error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); return (-2); } RTP_DEBUG_OUTPUT_STR("rtp_net_sendto: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); return (-1); } return (result); }
/*----------------------------------------------------------------------* rtp_net_bind *----------------------------------------------------------------------*/ int rtp_net_bind (RTP_HANDLE sockHandle, unsigned char *ipAddr, int port, int type) { int result; struct sockaddr_in sin; unsigned long in_addr = 0; memset(&sin, 0, sizeof (sin)); if (ipAddr) { unsigned char *ptr = (unsigned char *) &in_addr; if (type == RTP_NET_TYPE_IPV4) { ptr[0] = ipAddr[0]; ptr[1] = ipAddr[1]; ptr[2] = ipAddr[2]; ptr[3] = ipAddr[3]; } else { /* ----------------------------------- */ /* RTP_NET_TYPE_IPV6 not yet supported */ /* ----------------------------------- */ return (-1); } } else { in_addr = INADDR_ANY; } sin.sin_family = AF_INET; sin.sin_addr.s_addr = in_addr; sin.sin_port = htons((unsigned short)port); /* ----------------------------------- */ /* Clear the error state by setting */ /* to 0. */ /* ----------------------------------- */ set_errno (0); if (bind ((int) sockHandle, (PSOCKADDR) &sin, sizeof (sin)) != 0) { result = xn_getlasterror(); if (result == EADDRINUSE) { #ifdef RTP_DEBUG RTP_DEBUG_OUTPUT_STR("rtp_net_bind: non-fatal error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-2); } else { #ifdef RTP_DEBUG RTP_DEBUG_OUTPUT_STR("rtp_net_bind: error returned "); RTP_DEBUG_OUTPUT_INT(result); RTP_DEBUG_OUTPUT_STR(".\n"); #endif return (-1); } } return (0); }