/***********************************************/ /* */ /* psocket.h - Portable socket library */ /* */ /* Author - Noname */ /* */ /* E-mail - */ /* */ /* License - GNU GPL */ /* */ /***********************************************/ /**********************/ /* HEADER FILES */ /**********************/ #ifdef WINDOWS #include #endif #ifdef LINUX #include #include #include #include #endif /**********************/ /* WINSOCK VERSION */ /**********************/ #ifdef WINDOWS #define WINSOCK_V MAKEWORD(2, 0) #endif /**********************/ /* SOCKET_ERROR */ /* DEFINE FOR LINUX */ /**********************/ #ifdef SOCKET_ERROR #undef SOCKET_ERROR #define SOCKET_ERROR -1 #endif /**********************/ /* GLOBAL */ /* WSADATA STRUCT */ /**********************/ #ifdef WINDOWS struct WSAData wsaData; #endif /**********************/ /* COMMON PORTS */ /**********************/ #define ECHO_PORT 7 #define DAYTIME_PORT 13 #define FTP_PORT 21 #define SSH_PORT 22 #define TELNET_PORT 23 #define WINGATE_PORT 23 #define SMTP_PORT 25 #define GOPHER_PORT 70 #define FINGER_PORT 79 #define HTTP_PORT 80 #define POP3_PORT 110 #define IMAP_PORT 143 #define IRC_PORT 667 #define SOCKS_PORT 1080 #define HTTP_PROXY_PORT 8080 /**********************/ /* USEFUL DEFINES */ /**********************/ #ifndef SUCCESS #define SUCCESS 1 #endif #ifndef FAILURE #define FAILURE 0 #endif /**********************/ /* FUNCTIONS */ /* DECLARATION */ /**********************/ int psl_init(void); //Initialize Winsock on Windows sysyem int psl_cleanup(void); //Cleanup Winsock on Windows system int psl_close(int sck); //Chiude un socket struct sockaddr_in *psl_fillsockaddr(struct sockaddr_in *sa, char *address, unsigned int port); //Fill a sockaddr_in structure int psl_inet_aton(char *addr, unsigned long *sin_addr); //Portable inet_aton function unsigned long psl_inet_addr(char *addr); //Portable inet_addr function char *psl_resolve(char *name); //Resolve a name char *psl_iplookup(char *ip); //Look up an IP int psl_tcp_socket(struct sockaddr_in *sa); //Create a TCP connection int psl_tcp_server(struct sockaddr_in *sa, unsigned int backlog); //Create a TCP server int psl_udp_socket(struct sockaddr_in *sa); //Create an UDP socket int psl_udp_server(struct sockaddr_in *sa); //Create an UDP server int psl_write(int socket, char *buffer, unsigned int len); //Portable socket write function int psl_read(int socket, char *buffer, unsigned int size); //Portable socket read function /**********************/ /* FUNCTIONS */ /* IMPLEMENTATION */ /**********************/ /***********************************************************/ /* */ /* FUNCTION: psl_init */ /* */ /* SYNOPSIS: int psl_init(void) */ /* */ /* DESCRIPTION: initialize Winsock on Windows system. */ /* Call this function before any operation */ /* with sockets, for portability. */ /* Do nothing in Linux system. */ /* */ /* RETURN VALUE: return 1 on success or 0 on failure. */ /* On Linux return always 1. */ /* */ /***********************************************************/ int psl_init(void) { #ifdef WINDOWS if(WSAStartup(WINSOCK_V, &wsaData) == 0) return SUCCESS; else return FAILURE; #endif #ifdef LINUX return SUCCESS; #endif } /***********************************************************/ /* */ /* FUNCTION: psl_cleanup */ /* */ /* SYNOPSIS: int psl_cleanup(void) */ /* */ /* DESCRIPTION: cleanup Winsock on Windows system. */ /* Call this function at the end of operation */ /* with socket, for portability. */ /* Does nothing in Linux system. */ /* */ /* RETURN VALUE: return 1 on success or 0 on failure. */ /* On Linux return always 1. */ /* */ /***********************************************************/ int psl_cleanup(void) { #ifdef WINDOWS if(WSACleanup() == 0) return SUCCESS; else return FAILURE; #endif #ifdef LINUX return SUCCESS; #endif } /***********************************************************/ /* */ /* FUNCTION: psl_close */ /* */ /* SYNOPSIS: int psl_close(int socket) */ /* */ /* DESCRIPTION: close a socket. */ /* */ /* RETURN VALUE: return 1 on success or 0 on failure. */ /* */ /***********************************************************/ int psl_close(int sck) { shutdown(sck, 2); #ifdef WINDOWS if(closesocket(sck) == SOCKET_ERROR) return 0; #endif #ifdef LINUX if(close(sck) == SOCKET_ERROR) return 0; #endif return 1; } /***********************************************************/ /* */ /* FUNCTION: psl_fillsockaddr */ /* */ /* SYNOPSIS: struct sockaddr_in *psl_fillsockaddr( */ /* struct sockaddr_in *sa, */ /* char *address, */ /* unsigned int port) */ /* */ /* DESCRIPTION: Fill a sockaddr_in struct with: */ /* the remote IP address (or local if) */ /* the port */ /* */ /* RETURN VALUE: return the pointer to the filled struct, */ /* NULL on error. */ /* */ /***********************************************************/ struct sockaddr_in *psl_fillsockaddr(struct sockaddr_in *sa, char *address, unsigned int port) { char *ptraddr; sa->sin_port = htons((unsigned short) port); if(psl_inet_addr(address) == SOCKET_ERROR) { if((ptraddr = psl_resolve(address)) == NULL) return NULL; } else ptraddr = address; sa->sin_addr.s_addr = psl_inet_addr(ptraddr); return sa; } /***********************************************************/ /* */ /* FUNCTION: psl_inet_aton */ /* */ /* SYNOPSIS: int psl_inet_aton( */ /* char *addr, */ /* unsigned long *sin_addr) */ /* */ /* DESCRIPTION: convert a dotted decimal IP address to */ /* long. */ /* */ /* RETURN VALUE: return 0 if the IP isn't in dotted */ /* decimal notation, 1 otherwise. */ /* */ /***********************************************************/ int psl_inet_aton(char *addr, unsigned long *sin_addr) { #ifdef WINDOWS if((*sin_addr = inet_addr(addr)) == INADDR_NONE) return 0; else return 1; #endif #ifdef LINUX return inet_aton(addr, sin_addr); #endif } /***********************************************************/ /* */ /* FUNCTION: psl_inet_addr */ /* */ /* SYNOPSIS: unsigned long psl_inet_addr(char *addr) */ /* */ /* DESCRIPTION: convert a dotted decimal IP address to */ /* long. */ /* */ /* RETURN VALUE: return a long if the IP is in correct */ /* decimal notation, 0 otherwise. */ /* */ /***********************************************************/ unsigned long psl_inet_addr(char *addr) { #ifdef WINDOWS unsigned long uladdr; if((uladdr = inet_addr(addr)) == INADDR_NONE) return 0; else return uladdr; #endif #ifdef LINUX unsigned long sin_addr; if(inet_aton(addr, &sin_addr) == 0) return 0; else return sin_addr; #endif } /***********************************************************/ /* */ /* FUNCTION: psl_resolve */ /* */ /* SYNOPSIS: char *psl_resolve(char *name) */ /* */ /* DESCRIPTION: resolve a name */ /* */ /* RETURN VALUE: return an IP address on success, NULL */ /* otherwise. */ /* */ /***********************************************************/ char *psl_resolve(char *name) { struct hostent *he = NULL; he = gethostbyname(name); if(!he) { return NULL; } return inet_ntoa(*(struct in_addr*) he->h_addr_list[0]); } /***********************************************************/ /* */ /* FUNCTION: psl_iplookup */ /* */ /* SYNOPSIS: char *psl_iplookup(char *ip) */ /* */ /* DESCRIPTION: lookup an IP */ /* */ /* RETURN VALUE: return an hostname address on success, */ /* NULL otherwise. */ /* */ /***********************************************************/ char *psl_iplookup(char *ip) { struct hostent *he = NULL; unsigned long addr; addr = psl_inet_addr(ip); he = gethostbyaddr((const char *) &addr, 4, AF_INET); if(!he) { return NULL; } else return he->h_name; } /***********************************************************/ /* */ /* FUNCTION: psl_tcp_socket */ /* */ /* SYNOPSIS: int psl_tcp_socket(struct sockaddr_in *sa) */ /* */ /* DESCRIPTION: create a TCP connection. */ /* You can fill the sockaddr_in struct with */ /* psl_fillsockaddr. */ /* */ /* RETURN VALUE: return the socket (int) on success, 0 on */ /* error. */ /* */ /***********************************************************/ int psl_tcp_socket(struct sockaddr_in *sa) { int sck; sa->sin_family = AF_INET; if((sck = socket(AF_INET, SOCK_STREAM, 0)) == SOCKET_ERROR) return 0; if(connect(sck, (struct sockaddr *) sa, sizeof(struct sockaddr_in)) == SOCKET_ERROR) return 0; return sck; } /***********************************************************/ /* */ /* FUNCTION: psl_tcp_server */ /* */ /* SYNOPSIS: int psl_tcp_server(struct sockaddr_in *sa, */ /* unsigned int backlog) */ /* */ /* DESCRIPTION: create a TCP server that can accept */ /* 'backlog' connection simultainly. */ /* You can fill the sockaddr_in struct with */ /* psl_fillsockaddr. */ /* */ /* RETURN VALUE: return the socket (int) on success, 0 on */ /* error. */ /* */ /***********************************************************/ int psl_tcp_server(struct sockaddr_in *sa, unsigned int backlog) { int sck; sa->sin_family = AF_INET; if((sck = socket(AF_INET, SOCK_STREAM, 0)) == SOCKET_ERROR) return 0; if(bind(sck, (struct sockaddr *) sa, sizeof(struct sockaddr_in)) == SOCKET_ERROR) return 0; if(listen(sck, backlog) == SOCKET_ERROR) return 0; return sck; } /***********************************************************/ /* */ /* FUNCTION: psl_udp_socket */ /* */ /* SYNOPSIS: int psl_udp_socket(struct sockaddr_in *sa) */ /* */ /* DESCRIPTION: create an UDP socket */ /* */ /* RETURN VALUE: return the socket (int) on success, 0 */ /* on error. */ /* */ /***********************************************************/ int psl_udp_socket(struct sockaddr_in *sa) { int sck; sa->sin_family = AF_INET; if((sck = socket(AF_INET, SOCK_DGRAM, 0)) == SOCKET_ERROR) return 0; return sck; } /***********************************************************/ /* */ /* FUNCTION: psl_udp_server */ /* */ /* SYNOPSIS: int psl_udp_server(struct sockaddr_in *sa) */ /* */ /* DESCRIPTION: create an UDP server */ /* */ /* RETURN VALUE: return the socket (int) on success, 0 */ /* otherwise. */ /* */ /***********************************************************/ int psl_udp_server(struct sockaddr_in *sa) { int sck; sa->sin_family = AF_INET; if((sck = socket(AF_INET, SOCK_DGRAM, 0)) == SOCKET_ERROR) return 0; if(bind(sck, (struct sockaddr *) &sa, sizeof(struct sockaddr_in)) == SOCKET_ERROR) return 0; return sck; } /***********************************************************/ /* */ /* FUNCTION: psl_write */ /* */ /* SYNOPSIS: int psl_write(int socket, char *buffer, */ /* unsigned int len) */ /* */ /* DESCRIPTION: portable socket write function. */ /* Write len bytes of buffer to socket. */ /* */ /* RETURN VALUE: return the number of bytes sent, -1 on */ /* error. */ /* */ /***********************************************************/ int psl_write(int socket, char *buffer, unsigned int len) { #ifdef WINDOWS return send(socket, buffer, len, 0); #endif #ifdef LINUX return write(socket, buffer, len); #endif } /***********************************************************/ /* */ /* FUNCTION: psl_read */ /* */ /* SYNOPSIS: int psl_read(int socket, char *buffer, */ /* unsigned int size) */ /* */ /* DESCRIPTION: portable socket read function. */ /* Read len byte from socket and copy it in */ /* buffer. */ /* */ /* RETURN VALUE: return the number of bytes read, -1 on */ /* error, 0 if the connection has been */ /* closed. */ /* */ /***********************************************************/ int psl_read(int socket, char *buffer, unsigned int size) { #ifdef WINDOWS return recv(socket, buffer, size, 0); #endif #ifdef LINUX return read(socket, buffer, size); #endif } /*-------------------------[EOF]-------------(psocket.h)---*/