/** * xrdp: A Remote Desktop Protocol server. * * Copyright (C) Jay Sorg 2004-2014 * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * * generic operating system calls * * put all the os / arch define in here you want */ /* To test for Windows (64 bit or 32 bit) use _WIN32 and _WIN64 in addition for 64 bit windows. _WIN32 is defined for both. To test for Linux use __linux__. To test for BSD use BSD */ #if defined(HAVE_CONFIG_H) #include "config_ac.h" #endif #if defined(_WIN32) #include #include #else /* fix for solaris 10 with gcc 3.3.2 problem */ #if defined(sun) || defined(__sun) #define ctid_t id_t #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #endif #include #include #include #include #include /* this is so we can use #ifdef BSD later */ /* This is the recommended way of detecting BSD in the FreeBSD Porter's Handbook. */ #if (defined(__unix__) || defined(unix)) && !defined(USG) #include #endif #include "os_calls.h" #include "arch.h" #include "log.h" /* for clearenv() */ #if defined(_WIN32) #else extern char **environ; #endif #if defined(__linux__) #include #endif /* sys/ucred.h needs to be included to use struct xucred * in FreeBSD and OS X. No need for other BSDs */ #if defined(__FreeBSD__) || defined(__APPLE__) #include #endif /* for solaris */ #if !defined(PF_LOCAL) #define PF_LOCAL AF_UNIX #endif #if !defined(INADDR_NONE) #define INADDR_NONE ((unsigned long)-1) #endif /*****************************************************************************/ int APP_CC g_rm_temp_dir(void) { return 0; } /*****************************************************************************/ int APP_CC g_mk_temp_dir(const char *app_name) { if (!g_directory_exist("/tmp/.xrdp")) { if (!g_create_dir("/tmp/.xrdp")) { /* if failed, still check if it got created by someone else */ if (!g_directory_exist("/tmp/.xrdp")) { printf("g_mk_temp_dir: g_create_dir failed\n"); return 1; } } g_chmod_hex("/tmp/.xrdp", 0x1777); } return 0; } /*****************************************************************************/ void APP_CC g_init(const char *app_name) { #if defined(_WIN32) WSADATA wsadata; WSAStartup(2, &wsadata); #endif /* In order to get g_mbstowcs and g_wcstombs to work properly with UTF-8 non-ASCII characters, LC_CTYPE cannot be "C" or blank. To select UTF-8 encoding without specifying any countries/languages, "C.UTF-8" is used but provided in few systems. See also: https://sourceware.org/glibc/wiki/Proposals/C.UTF-8 */ char *lc_ctype; lc_ctype = setlocale(LC_CTYPE, "C.UTF-8"); if (lc_ctype == NULL) { /* use en_US.UTF-8 instead if not available */ setlocale(LC_CTYPE, "en_US.UTF-8"); } g_mk_temp_dir(app_name); } /*****************************************************************************/ void APP_CC g_deinit(void) { #if defined(_WIN32) WSACleanup(); #endif g_rm_temp_dir(); } /*****************************************************************************/ /* allocate memory, returns a pointer to it, size bytes are allocated, if zero is non zero, each byte will be set to zero */ void *APP_CC g_malloc(int size, int zero) { char *rv; rv = (char *)malloc(size); if (zero) { if (rv != 0) { memset(rv, 0, size); } } return rv; } /*****************************************************************************/ /* free the memory pointed to by ptr, ptr can be zero */ void APP_CC g_free(void *ptr) { if (ptr != 0) { free(ptr); } } /*****************************************************************************/ /* output text to stdout, try to use g_write / g_writeln instead to avoid linux / windows EOL problems */ void DEFAULT_CC g_printf(const char *format, ...) { va_list ap; va_start(ap, format); vfprintf(stdout, format, ap); va_end(ap); } /*****************************************************************************/ void DEFAULT_CC g_sprintf(char *dest, const char *format, ...) { va_list ap; va_start(ap, format); vsprintf(dest, format, ap); va_end(ap); } /*****************************************************************************/ int DEFAULT_CC g_snprintf(char *dest, int len, const char *format, ...) { int err; va_list ap; va_start(ap, format); err = vsnprintf(dest, len, format, ap); va_end(ap); return err; } /*****************************************************************************/ void DEFAULT_CC g_writeln(const char *format, ...) { va_list ap; va_start(ap, format); vfprintf(stdout, format, ap); va_end(ap); #if defined(_WIN32) g_printf("\r\n"); #else g_printf("\n"); #endif } /*****************************************************************************/ void DEFAULT_CC g_write(const char *format, ...) { va_list ap; va_start(ap, format); vfprintf(stdout, format, ap); va_end(ap); } /*****************************************************************************/ /* produce a hex dump */ void APP_CC g_hexdump(char *p, int len) { unsigned char *line; int i; int thisline; int offset; line = (unsigned char *)p; offset = 0; while (offset < len) { g_printf("%04x ", offset); thisline = len - offset; if (thisline > 16) { thisline = 16; } for (i = 0; i < thisline; i++) { g_printf("%02x ", line[i]); } for (; i < 16; i++) { g_printf(" "); } for (i = 0; i < thisline; i++) { g_printf("%c", (line[i] >= 0x20 && line[i] < 0x7f) ? line[i] : '.'); } g_writeln("%s", ""); offset += thisline; line += thisline; } } /*****************************************************************************/ void APP_CC g_memset(void *ptr, int val, int size) { memset(ptr, val, size); } /*****************************************************************************/ void APP_CC g_memcpy(void *d_ptr, const void *s_ptr, int size) { memcpy(d_ptr, s_ptr, size); } /*****************************************************************************/ int APP_CC g_getchar(void) { return getchar(); } /*****************************************************************************/ /*Returns 0 on success*/ int APP_CC g_tcp_set_no_delay(int sck) { int ret = 1; /* error */ int option_value; socklen_t option_len; option_len = sizeof(option_value); /* SOL_TCP IPPROTO_TCP */ if (getsockopt(sck, IPPROTO_TCP, TCP_NODELAY, (char *)&option_value, &option_len) == 0) { if (option_value == 0) { option_value = 1; option_len = sizeof(option_value); if (setsockopt(sck, IPPROTO_TCP, TCP_NODELAY, (char *)&option_value, option_len) == 0) { ret = 0; /* success */ } else { g_writeln("Error setting tcp_nodelay"); } } } else { g_writeln("Error getting tcp_nodelay"); } return ret; } /*****************************************************************************/ /*Returns 0 on success*/ int APP_CC g_tcp_set_keepalive(int sck) { int ret = 1; /* error */ int option_value; socklen_t option_len; option_len = sizeof(option_value); /* SOL_TCP IPPROTO_TCP */ if (getsockopt(sck, SOL_SOCKET, SO_KEEPALIVE, (char *)&option_value, &option_len) == 0) { if (option_value == 0) { option_value = 1; option_len = sizeof(option_value); if (setsockopt(sck, SOL_SOCKET, SO_KEEPALIVE, (char *)&option_value, option_len) == 0) { ret = 0; /* success */ } else { g_writeln("Error setting tcp_keepalive"); } } } else { g_writeln("Error getting tcp_keepalive"); } return ret; } /*****************************************************************************/ /* returns a newly created socket or -1 on error */ /* in win32 a socket is an unsigned int, in linux, it's an int */ int APP_CC g_tcp_socket(void) { int rv; int option_value; socklen_t option_len; #if defined(XRDP_ENABLE_IPV6) rv = (int)socket(AF_INET6, SOCK_STREAM, 0); #else rv = (int)socket(AF_INET, SOCK_STREAM, 0); #endif if (rv < 0) { return -1; } #if defined(XRDP_ENABLE_IPV6) option_len = sizeof(option_value); if (getsockopt(rv, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&option_value, &option_len) == 0) { if (option_value != 0) { #if defined(XRDP_ENABLE_IPV6ONLY) option_value = 1; #else option_value = 0; #endif option_len = sizeof(option_value); if (setsockopt(rv, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&option_value, option_len) < 0) { log_message(LOG_LEVEL_ERROR, "g_tcp_socket: setsockopt() failed\n"); } } } #endif option_len = sizeof(option_value); if (getsockopt(rv, SOL_SOCKET, SO_REUSEADDR, (char *)&option_value, &option_len) == 0) { if (option_value == 0) { option_value = 1; option_len = sizeof(option_value); if (setsockopt(rv, SOL_SOCKET, SO_REUSEADDR, (char *)&option_value, option_len) < 0) { log_message(LOG_LEVEL_ERROR, "g_tcp_socket: setsockopt() failed\n"); } } } option_len = sizeof(option_value); if (getsockopt(rv, SOL_SOCKET, SO_SNDBUF, (char *)&option_value, &option_len) == 0) { if (option_value < (1024 * 32)) { option_value = 1024 * 32; option_len = sizeof(option_value); if (setsockopt(rv, SOL_SOCKET, SO_SNDBUF, (char *)&option_value, option_len) < 0) { log_message(LOG_LEVEL_ERROR, "g_tcp_socket: setsockopt() failed\n"); } } } return rv; } /*****************************************************************************/ /* returns error */ int APP_CC g_sck_set_send_buffer_bytes(int sck, int bytes) { int option_value; socklen_t option_len; option_value = bytes; option_len = sizeof(option_value); if (setsockopt(sck, SOL_SOCKET, SO_SNDBUF, (char *)&option_value, option_len) != 0) { return 1; } return 0; } /*****************************************************************************/ /* returns error */ int APP_CC g_sck_get_send_buffer_bytes(int sck, int *bytes) { int option_value; socklen_t option_len; option_value = 0; option_len = sizeof(option_value); if (getsockopt(sck, SOL_SOCKET, SO_SNDBUF, (char *)&option_value, &option_len) != 0) { return 1; } *bytes = option_value; return 0; } /*****************************************************************************/ /* returns error */ int APP_CC g_sck_set_recv_buffer_bytes(int sck, int bytes) { int option_value; socklen_t option_len; option_value = bytes; option_len = sizeof(option_value); if (setsockopt(sck, SOL_SOCKET, SO_RCVBUF, (char *)&option_value, option_len) != 0) { return 1; } return 0; } /*****************************************************************************/ /* returns error */ int APP_CC g_sck_get_recv_buffer_bytes(int sck, int *bytes) { int option_value; socklen_t option_len; option_value = 0; option_len = sizeof(option_value); if (getsockopt(sck, SOL_SOCKET, SO_RCVBUF, (char *)&option_value, &option_len) != 0) { return 1; } *bytes = option_value; return 0; } /*****************************************************************************/ int APP_CC g_sck_local_socket(void) { #if defined(_WIN32) return 0; #else return socket(PF_LOCAL, SOCK_STREAM, 0); #endif } /*****************************************************************************/ /* returns error */ int APP_CC g_sck_get_peer_cred(int sck, int *pid, int *uid, int *gid) { #if defined(SO_PEERCRED) socklen_t ucred_length; struct myucred { pid_t pid; uid_t uid; gid_t gid; } credentials; ucred_length = sizeof(credentials); if (getsockopt(sck, SOL_SOCKET, SO_PEERCRED, &credentials, &ucred_length)) { return 1; } if (pid != 0) { *pid = credentials.pid; } if (uid != 0) { *uid = credentials.uid; } if (gid != 0) { *gid = credentials.gid; } return 0; #elif defined(LOCAL_PEERCRED) /* FreeBSD, OS X reach here*/ struct xucred xucred; unsigned int xucred_length; xucred_length = sizeof(xucred); if (getsockopt(sck, SOL_SOCKET, LOCAL_PEERCRED, &xucred, &xucred_length)) { return 1; } if (pid !=0) { *pid = 0; /* can't get pid in FreeBSD, OS X */ } if (uid != 0) { *uid = xucred.cr_uid; } if (gid != 0) { *gid = xucred.cr_gid; } return 0; #else return 1; #endif } /*****************************************************************************/ void APP_CC g_sck_close(int sck) { #if defined(_WIN32) closesocket(sck); #else char sockname[128]; union { struct sockaddr sock_addr; struct sockaddr_in sock_addr_in; #if defined(XRDP_ENABLE_IPV6) struct sockaddr_in6 sock_addr_in6; #endif } sock_info; socklen_t sock_len = sizeof(sock_info); memset(&sock_info, 0, sizeof(sock_info)); if (getsockname(sck, &sock_info.sock_addr, &sock_len) == 0) { switch (sock_info.sock_addr.sa_family) { case AF_INET: { struct sockaddr_in *sock_addr_in = &sock_info.sock_addr_in; g_snprintf(sockname, sizeof(sockname), "AF_INET %s:%d", inet_ntoa(sock_addr_in->sin_addr), ntohs(sock_addr_in->sin_port)); break; } #if defined(XRDP_ENABLE_IPV6) case AF_INET6: { char addr[48]; struct sockaddr_in6 *sock_addr_in6 = &sock_info.sock_addr_in6; g_snprintf(sockname, sizeof(sockname), "AF_INET6 %s:%d", inet_ntop(sock_addr_in6->sin6_family, &sock_addr_in6->sin6_addr, addr, sizeof(addr)), ntohs(sock_addr_in6->sin6_port)); break; } #endif case AF_UNIX: g_snprintf(sockname, sizeof(sockname), "AF_UNIX"); break; default: g_snprintf(sockname, sizeof(sockname), "unknown family %d", sock_info.sock_addr.sa_family); break; } } else { log_message(LOG_LEVEL_WARNING, "getsockname() failed on socket %d: %s", sck, strerror(errno)); if (errno == EBADF || errno == ENOTSOCK) { return; } g_snprintf(sockname, sizeof(sockname), "unknown"); } if (close(sck) == 0) { log_message(LOG_LEVEL_DEBUG, "Closed socket %d (%s)", sck, sockname); } else { log_message(LOG_LEVEL_WARNING, "Cannot close socket %d (%s): %s", sck, sockname, strerror(errno)); } #endif } /*****************************************************************************/ /* returns error, zero is good */ #if defined(XRDP_ENABLE_IPV6) int APP_CC g_tcp_connect(int sck, const char *address, const char *port) { int res = 0; struct addrinfo p; struct addrinfo *h = (struct addrinfo *)NULL; struct addrinfo *rp = (struct addrinfo *)NULL; /* initialize (zero out) local variables: */ g_memset(&p, 0, sizeof(struct addrinfo)); /* in IPv6-enabled environments, set the AI_V4MAPPED * flag in ai_flags and specify ai_family=AF_INET6 in * order to ensure that getaddrinfo() returns any * available IPv4-mapped addresses in case the target * host does not have a true IPv6 address: */ p.ai_socktype = SOCK_STREAM; p.ai_protocol = IPPROTO_TCP; p.ai_flags = AI_ADDRCONFIG | AI_V4MAPPED; p.ai_family = AF_INET6; if (g_strcmp(address, "127.0.0.1") == 0) { res = getaddrinfo("::1", port, &p, &h); } else { res = getaddrinfo(address, port, &p, &h); } if (res != 0) { log_message(LOG_LEVEL_ERROR, "g_tcp_connect: getaddrinfo() failed: %s", gai_strerror(res)); } if (res > -1) { if (h != NULL) { for (rp = h; rp != NULL; rp = rp->ai_next) { rp = h; res = connect(sck, (struct sockaddr *)(rp->ai_addr), rp->ai_addrlen); if (res != -1) { break; /* Success */ } } } } /* Mac OSX connect() returns -1 for already established connections */ if (res == -1 && errno == EISCONN) { res = 0; } return res; } #else int APP_CC g_tcp_connect(int sck, const char* address, const char* port) { struct sockaddr_in s; struct hostent* h; int res; g_memset(&s, 0, sizeof(struct sockaddr_in)); s.sin_family = AF_INET; s.sin_port = htons((tui16)atoi(port)); s.sin_addr.s_addr = inet_addr(address); if (s.sin_addr.s_addr == INADDR_NONE) { h = gethostbyname(address); if (h != 0) { if (h->h_name != 0) { if (h->h_addr_list != 0) { if ((*(h->h_addr_list)) != 0) { s.sin_addr.s_addr = *((int*)(*(h->h_addr_list))); } } } } } res = connect(sck, (struct sockaddr*)&s, sizeof(struct sockaddr_in)); /* Mac OSX connect() returns -1 for already established connections */ if (res == -1 && errno == EISCONN) { res = 0; } return res; } #endif /*****************************************************************************/ /* returns error, zero is good */ int APP_CC g_sck_local_connect(int sck, const char *port) { #if defined(_WIN32) return -1; #else struct sockaddr_un s; memset(&s, 0, sizeof(struct sockaddr_un)); s.sun_family = AF_UNIX; strncpy(s.sun_path, port, sizeof(s.sun_path)); s.sun_path[sizeof(s.sun_path) - 1] = 0; return connect(sck, (struct sockaddr *)&s, sizeof(struct sockaddr_un)); #endif } /*****************************************************************************/ int APP_CC g_sck_set_non_blocking(int sck) { unsigned long i; #if defined(_WIN32) i = 1; ioctlsocket(sck, FIONBIO, &i); #else i = fcntl(sck, F_GETFL); i = i | O_NONBLOCK; if (fcntl(sck, F_SETFL, i) < 0) { log_message(LOG_LEVEL_ERROR, "g_sck_set_non_blocking: fcntl() failed\n"); } #endif return 0; } #if defined(XRDP_ENABLE_IPV6) /*****************************************************************************/ /* return boolean */ static int APP_CC address_match(const char *address, struct addrinfo *j) { struct sockaddr_in *ipv4_in; struct sockaddr_in6 *ipv6_in; if (address == 0) { return 1; } if (address[0] == 0) { return 1; } if (g_strcmp(address, "0.0.0.0") == 0) { return 1; } if ((g_strcmp(address, "127.0.0.1") == 0) || (g_strcmp(address, "::1") == 0) || (g_strcmp(address, "localhost") == 0)) { if (j->ai_addr != 0) { if (j->ai_addr->sa_family == AF_INET) { ipv4_in = (struct sockaddr_in *) (j->ai_addr); if (inet_pton(AF_INET, "127.0.0.1", &(ipv4_in->sin_addr))) { return 1; } } if (j->ai_addr->sa_family == AF_INET6) { ipv6_in = (struct sockaddr_in6 *) (j->ai_addr); if (inet_pton(AF_INET6, "::1", &(ipv6_in->sin6_addr))) { return 1; } } } } if (j->ai_addr != 0) { if (j->ai_addr->sa_family == AF_INET) { ipv4_in = (struct sockaddr_in *) (j->ai_addr); if (inet_pton(AF_INET, address, &(ipv4_in->sin_addr))) { return 1; } } if (j->ai_addr->sa_family == AF_INET6) { ipv6_in = (struct sockaddr_in6 *) (j->ai_addr); if (inet_pton(AF_INET6, address, &(ipv6_in->sin6_addr))) { return 1; } } } return 0; } #endif #if defined(XRDP_ENABLE_IPV6) /*****************************************************************************/ /* returns error, zero is good */ static int APP_CC g_tcp_bind_flags(int sck, const char *port, const char *address, int flags) { int res; int error; struct addrinfo hints; struct addrinfo *i; res = -1; g_memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_flags = flags; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; error = getaddrinfo(NULL, port, &hints, &i); if (error == 0) { while ((i != 0) && (res < 0)) { if (address_match(address, i)) { res = bind(sck, i->ai_addr, i->ai_addrlen); } i = i->ai_next; } } return res; } /*****************************************************************************/ /* returns error, zero is good */ int APP_CC g_tcp_bind(int sck, const char *port) { int flags; flags = AI_ADDRCONFIG | AI_PASSIVE; return g_tcp_bind_flags(sck, port, 0, flags); } #else int APP_CC g_tcp_bind(int sck, const char* port) { struct sockaddr_in s; memset(&s, 0, sizeof(struct sockaddr_in)); s.sin_family = AF_INET; s.sin_port = htons((tui16)atoi(port)); s.sin_addr.s_addr = INADDR_ANY; return bind(sck, (struct sockaddr*)&s, sizeof(struct sockaddr_in)); } #endif /*****************************************************************************/ int APP_CC g_sck_local_bind(int sck, const char *port) { #if defined(_WIN32) return -1; #else struct sockaddr_un s; memset(&s, 0, sizeof(struct sockaddr_un)); s.sun_family = AF_UNIX; strncpy(s.sun_path, port, sizeof(s.sun_path)); s.sun_path[sizeof(s.sun_path) - 1] = 0; return bind(sck, (struct sockaddr *)&s, sizeof(struct sockaddr_un)); #endif } #if defined(XRDP_ENABLE_IPV6) /*****************************************************************************/ /* returns error, zero is good */ int APP_CC g_tcp_bind_address(int sck, const char *port, const char *address) { int flags; flags = AI_ADDRCONFIG | AI_PASSIVE; return g_tcp_bind_flags(sck, port, address, flags); } #else int APP_CC g_tcp_bind_address(int sck, const char* port, const char* address) { struct sockaddr_in s; memset(&s, 0, sizeof(struct sockaddr_in)); s.sin_family = AF_INET; s.sin_port = htons((tui16)atoi(port)); s.sin_addr.s_addr = INADDR_ANY; if (inet_aton(address, &s.sin_addr) < 0) { return -1; /* bad address */ } return bind(sck, (struct sockaddr*)&s, sizeof(struct sockaddr_in)); } #endif /*****************************************************************************/ /* returns error, zero is good */ int APP_CC g_sck_listen(int sck) { return listen(sck, 2); } /*****************************************************************************/ int APP_CC g_tcp_accept(int sck) { int ret ; char ipAddr[256] ; struct sockaddr_in s; socklen_t i; i = sizeof(struct sockaddr_in); memset(&s, 0, i); ret = accept(sck, (struct sockaddr *)&s, &i); if(ret>0) { snprintf(ipAddr, 255, "A connection received from: %s port %d", inet_ntoa(s.sin_addr), ntohs(s.sin_port)); log_message(LOG_LEVEL_INFO, "%s", ipAddr); } return ret ; } /*****************************************************************************/ int APP_CC g_sck_accept(int sck, char *addr, int addr_bytes, char *port, int port_bytes) { int ret; char ipAddr[256]; struct sockaddr_in s; socklen_t i; i = sizeof(struct sockaddr_in); memset(&s, 0, i); ret = accept(sck, (struct sockaddr *)&s, &i); if (ret > 0) { g_snprintf(ipAddr, 255, "A connection received from: %s port %d", inet_ntoa(s.sin_addr), ntohs(s.sin_port)); log_message(LOG_LEVEL_INFO, "%s", ipAddr); if (s.sin_family == AF_INET) { g_snprintf(addr, addr_bytes, "%s", inet_ntoa(s.sin_addr)); g_snprintf(port, port_bytes, "%d", ntohs(s.sin_port)); } if (s.sin_family == AF_UNIX) { g_strncpy(addr, "", addr_bytes - 1); g_strncpy(port, "", port_bytes - 1); } } return ret; } /*****************************************************************************/ void APP_CC g_write_ip_address(int rcv_sck, char *ip_address, int bytes) { struct sockaddr_in s; struct in_addr in; socklen_t len; int ip_port; int ok; ok = 0; memset(&s, 0, sizeof(s)); len = sizeof(s); if (getpeername(rcv_sck, (struct sockaddr *)&s, &len) == 0) { memset(&in, 0, sizeof(in)); in.s_addr = s.sin_addr.s_addr; ip_port = ntohs(s.sin_port); if (ip_port != 0) { ok = 1; snprintf(ip_address, bytes, "%s:%d - socket: %d", inet_ntoa(in), ip_port, rcv_sck); } } if (!ok) { snprintf(ip_address, bytes, "NULL:NULL - socket: %d", rcv_sck); } } /*****************************************************************************/ void APP_CC g_sleep(int msecs) { #if defined(_WIN32) Sleep(msecs); #else usleep(msecs * 1000); #endif } /*****************************************************************************/ int APP_CC g_sck_last_error_would_block(int sck) { #if defined(_WIN32) return WSAGetLastError() == WSAEWOULDBLOCK; #else return (errno == EWOULDBLOCK) || (errno == EAGAIN) || (errno == EINPROGRESS); #endif } /*****************************************************************************/ int APP_CC g_sck_recv(int sck, void *ptr, int len, int flags) { #if defined(_WIN32) return recv(sck, (char *)ptr, len, flags); #else return recv(sck, ptr, len, flags); #endif } /*****************************************************************************/ int APP_CC g_sck_send(int sck, const void *ptr, int len, int flags) { #if defined(_WIN32) return send(sck, (const char *)ptr, len, flags); #else return send(sck, ptr, len, flags); #endif } /*****************************************************************************/ /* returns boolean */ int APP_CC g_sck_socket_ok(int sck) { int opt; socklen_t opt_len; opt_len = sizeof(opt); if (getsockopt(sck, SOL_SOCKET, SO_ERROR, (char *)(&opt), &opt_len) == 0) { if (opt == 0) { return 1; } } return 0; } /*****************************************************************************/ /* wait 'millis' milliseconds for the socket to be able to write */ /* returns boolean */ int APP_CC g_sck_can_send(int sck, int millis) { fd_set wfds; struct timeval time; int rv; time.tv_sec = millis / 1000; time.tv_usec = (millis * 1000) % 1000000; FD_ZERO(&wfds); if (sck > 0) { FD_SET(((unsigned int)sck), &wfds); rv = select(sck + 1, 0, &wfds, 0, &time); if (rv > 0) { return 1; } } return 0; } /*****************************************************************************/ /* wait 'millis' milliseconds for the socket to be able to receive */ /* returns boolean */ int APP_CC g_sck_can_recv(int sck, int millis) { fd_set rfds; struct timeval time; int rv; g_memset(&time, 0, sizeof(time)); time.tv_sec = millis / 1000; time.tv_usec = (millis * 1000) % 1000000; FD_ZERO(&rfds); if (sck > 0) { FD_SET(((unsigned int)sck), &rfds); rv = select(sck + 1, &rfds, 0, 0, &time); if (rv > 0) { return 1; } } return 0; } /*****************************************************************************/ int APP_CC g_sck_select(int sck1, int sck2) { fd_set rfds; struct timeval time; int max; int rv; g_memset(&time, 0, sizeof(struct timeval)); FD_ZERO(&rfds); if (sck1 > 0) { FD_SET(((unsigned int)sck1), &rfds); } if (sck2 > 0) { FD_SET(((unsigned int)sck2), &rfds); } max = sck1; if (sck2 > max) { max = sck2; } rv = select(max + 1, &rfds, 0, 0, &time); if (rv > 0) { rv = 0; if (FD_ISSET(((unsigned int)sck1), &rfds)) { rv = rv | 1; } if (FD_ISSET(((unsigned int)sck2), &rfds)) { rv = rv | 2; } } else { rv = 0; } return rv; } /*****************************************************************************/ /* returns boolean */ static int APP_CC g_fd_can_read(int fd) { fd_set rfds; struct timeval time; int rv; g_memset(&time, 0, sizeof(time)); FD_ZERO(&rfds); FD_SET(((unsigned int)fd), &rfds); rv = select(fd + 1, &rfds, 0, 0, &time); if (rv == 1) { return 1; } return 0; } /*****************************************************************************/ /* returns error */ /* O_NONBLOCK = 0x00000800 */ static int APP_CC g_set_nonblock(int fd) { int error; int flags; error = fcntl(fd, F_GETFL); if (error < 0) { return 1; } flags = error; if ((flags & O_NONBLOCK) != O_NONBLOCK) { flags |= O_NONBLOCK; error = fcntl(fd, F_SETFL, flags); if (error < 0) { return 1; } } return 0; } /*****************************************************************************/ /* returns 0 on error */ tintptr APP_CC g_create_wait_obj(char *name) { #ifdef _WIN32 tintptr obj; obj = (tintptr)CreateEvent(0, 1, 0, name); return obj; #else int fds[2]; int error; error = pipe(fds); if (error != 0) { return 0; } if (g_set_nonblock(fds[0]) != 0) { close(fds[0]); close(fds[1]); return 0; } if (g_set_nonblock(fds[1]) != 0) { close(fds[0]); close(fds[1]); return 0; } return (fds[1] << 16) | fds[0]; #endif } /*****************************************************************************/ /* returns 0 on error */ tintptr APP_CC g_create_wait_obj_from_socket(tintptr socket, int write) { #ifdef _WIN32 /* Create and return corresponding event handle for WaitForMultipleObjects */ WSAEVENT event; long lnetevent = 0; g_memset(&event, 0, sizeof(WSAEVENT)); event = WSACreateEvent(); lnetevent = (write ? FD_WRITE : FD_READ) | FD_CLOSE; if (WSAEventSelect(socket, event, lnetevent) == 0) { return (tbus)event; } else { return 0; } #else return socket; #endif } /*****************************************************************************/ void APP_CC g_delete_wait_obj_from_socket(tintptr wait_obj) { #ifdef _WIN32 if (wait_obj == 0) { return; } WSACloseEvent((HANDLE)wait_obj); #else #endif } /*****************************************************************************/ /* returns error */ int APP_CC g_set_wait_obj(tintptr obj) { #ifdef _WIN32 if (obj == 0) { return 0; } SetEvent((HANDLE)obj); return 0; #else int error; int fd; int written; int to_write; char buf[4] = "sig"; if (obj == 0) { return 0; } fd = obj & 0xffff; if (g_fd_can_read(fd)) { /* already signalled */ return 0; } fd = obj >> 16; to_write = 4; written = 0; while (written < to_write) { error = write(fd, buf + written, to_write - written); if (error == -1) { error = errno; if ((error == EAGAIN) || (error == EWOULDBLOCK) || (error == EINPROGRESS) || (error == EINTR)) { /* ok */ } else { return 1; } } else if (error > 0) { written += error; } else { return 1; } } return 0; #endif } /*****************************************************************************/ /* returns error */ int APP_CC g_reset_wait_obj(tintptr obj) { #ifdef _WIN32 if (obj == 0) { return 0; } ResetEvent((HANDLE)obj); return 0; #else char buf[4]; int error; int fd; if (obj == 0) { return 0; } fd = obj & 0xffff; while (g_fd_can_read(fd)) { error = read(fd, buf, 4); if (error == -1) { error = errno; if ((error == EAGAIN) || (error == EWOULDBLOCK) || (error == EINPROGRESS) || (error == EINTR)) { /* ok */ } else { return 1; } } else if (error == 0) { return 1; } } return 0; #endif } /*****************************************************************************/ /* returns boolean */ int APP_CC g_is_wait_obj_set(tintptr obj) { #ifdef _WIN32 if (obj == 0) { return 0; } if (WaitForSingleObject((HANDLE)obj, 0) == WAIT_OBJECT_0) { return 1; } return 0; #else if (obj == 0) { return 0; } return g_fd_can_read(obj & 0xffff); #endif } /*****************************************************************************/ /* returns error */ int APP_CC g_delete_wait_obj(tintptr obj) { #ifdef _WIN32 if (obj == 0) { return 0; } /* Close event handle */ CloseHandle((HANDLE)obj); return 0; #else if (obj == 0) { return 0; } close(obj & 0xffff); close(obj >> 16); return 0; #endif } /*****************************************************************************/ /* returns error */ int APP_CC g_obj_wait(tintptr *read_objs, int rcount, tintptr *write_objs, int wcount, int mstimeout) { #ifdef _WIN32 HANDLE handles[256]; DWORD count; DWORD error; int j; int i; j = 0; count = rcount + wcount; for (i = 0; i < rcount; i++) { handles[j++] = (HANDLE)(read_objs[i]); } for (i = 0; i < wcount; i++) { handles[j++] = (HANDLE)(write_objs[i]); } if (mstimeout < 1) { mstimeout = INFINITE; } error = WaitForMultipleObjects(count, handles, FALSE, mstimeout); if (error == WAIT_FAILED) { return 1; } return 0; #else fd_set rfds; fd_set wfds; struct timeval time; struct timeval *ptime; int i = 0; int res = 0; int max = 0; int sck = 0; max = 0; if (mstimeout < 1) { ptime = 0; } else { g_memset(&time, 0, sizeof(struct timeval)); time.tv_sec = mstimeout / 1000; time.tv_usec = (mstimeout % 1000) * 1000; ptime = &time; } FD_ZERO(&rfds); FD_ZERO(&wfds); /* Find the highest descriptor number in read_obj */ if (read_objs != NULL) { for (i = 0; i < rcount; i++) { sck = read_objs[i] & 0xffff; if (sck > 0) { FD_SET(sck, &rfds); if (sck > max) { max = sck; /* max holds the highest socket/descriptor number */ } } } } else if (rcount > 0) { g_writeln("Programming error read_objs is null"); return 1; /* error */ } if (write_objs != NULL) { for (i = 0; i < wcount; i++) { sck = (int)(write_objs[i]); if (sck > 0) { FD_SET(sck, &wfds); if (sck > max) { max = sck; /* max holds the highest socket/descriptor number */ } } } } else if (wcount > 0) { g_writeln("Programming error write_objs is null"); return 1; /* error */ } res = select(max + 1, &rfds, &wfds, 0, ptime); if (res < 0) { /* these are not really errors */ if ((errno == EAGAIN) || (errno == EWOULDBLOCK) || (errno == EINPROGRESS) || (errno == EINTR)) /* signal occurred */ { return 0; } return 1; /* error */ } return 0; #endif } /*****************************************************************************/ void APP_CC g_random(char *data, int len) { #if defined(_WIN32) int index; srand(g_time1()); for (index = 0; index < len; index++) { data[index] = (char)rand(); /* rand returns a number between 0 and RAND_MAX */ } #else int fd; memset(data, 0x44, len); fd = open("/dev/urandom", O_RDONLY); if (fd == -1) { fd = open("/dev/random", O_RDONLY); } if (fd != -1) { if (read(fd, data, len) != len) { } close(fd); } #endif } /*****************************************************************************/ int APP_CC g_abs(int i) { return abs(i); } /*****************************************************************************/ int APP_CC g_memcmp(const void *s1, const void *s2, int len) { return memcmp(s1, s2, len); } /*****************************************************************************/ /* returns -1 on error, else return handle or file descriptor */ int APP_CC g_file_open(const char *file_name) { #if defined(_WIN32) return (int)CreateFileA(file_name, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0); #else int rv; rv = open(file_name, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR); if (rv == -1) { /* can't open read / write, try to open read only */ rv = open(file_name, O_RDONLY); } return rv; #endif } /*****************************************************************************/ /* returns -1 on error, else return handle or file descriptor */ int APP_CC g_file_open_ex(const char *file_name, int aread, int awrite, int acreate, int atrunc) { #if defined(_WIN32) return -1; #else int rv; int flags; flags = 0; if (aread && awrite) { flags |= O_RDWR; } else if (aread) { flags |= O_RDONLY; } else if (awrite) { flags |= O_WRONLY; } if (acreate) { flags |= O_CREAT; } if (atrunc) { flags |= O_TRUNC; } rv = open(file_name, flags, S_IRUSR | S_IWUSR); return rv; #endif } /*****************************************************************************/ /* returns error, always 0 */ int APP_CC g_file_close(int fd) { #if defined(_WIN32) CloseHandle((HANDLE)fd); #else close(fd); #endif return 0; } /*****************************************************************************/ /* read from file, returns the number of bytes read or -1 on error */ int APP_CC g_file_read(int fd, char *ptr, int len) { #if defined(_WIN32) if (ReadFile((HANDLE)fd, (LPVOID)ptr, (DWORD)len, (LPDWORD)&len, 0)) { return len; } else { return -1; } #else return read(fd, ptr, len); #endif } /*****************************************************************************/ /* write to file, returns the number of bytes written or -1 on error */ int APP_CC g_file_write(int fd, const char *ptr, int len) { #if defined(_WIN32) if (WriteFile((HANDLE)fd, (LPVOID)ptr, (DWORD)len, (LPDWORD)&len, 0)) { return len; } else { return -1; } #else return write(fd, ptr, len); #endif } /*****************************************************************************/ /* move file pointer, returns offset on success, -1 on failure */ int APP_CC g_file_seek(int fd, int offset) { #if defined(_WIN32) int rv; rv = (int)SetFilePointer((HANDLE)fd, offset, 0, FILE_BEGIN); if (rv == (int)INVALID_SET_FILE_POINTER) { return -1; } else { return rv; } #else return (int)lseek(fd, offset, SEEK_SET); #endif } /*****************************************************************************/ /* do a write lock on a file */ /* return boolean */ int APP_CC g_file_lock(int fd, int start, int len) { #if defined(_WIN32) return LockFile((HANDLE)fd, start, 0, len, 0); #else struct flock lock; lock.l_type = F_WRLCK; lock.l_whence = SEEK_SET; lock.l_start = start; lock.l_len = len; if (fcntl(fd, F_SETLK, &lock) == -1) { return 0; } return 1; #endif } /*****************************************************************************/ /* returns error */ int APP_CC g_chmod_hex(const char *filename, int flags) { #if defined(_WIN32) return 0; #else int fl; fl = 0; fl |= (flags & 0x4000) ? S_ISUID : 0; fl |= (flags & 0x2000) ? S_ISGID : 0; fl |= (flags & 0x1000) ? S_ISVTX : 0; fl |= (flags & 0x0400) ? S_IRUSR : 0; fl |= (flags & 0x0200) ? S_IWUSR : 0; fl |= (flags & 0x0100) ? S_IXUSR : 0; fl |= (flags & 0x0040) ? S_IRGRP : 0; fl |= (flags & 0x0020) ? S_IWGRP : 0; fl |= (flags & 0x0010) ? S_IXGRP : 0; fl |= (flags & 0x0004) ? S_IROTH : 0; fl |= (flags & 0x0002) ? S_IWOTH : 0; fl |= (flags & 0x0001) ? S_IXOTH : 0; return chmod(filename, fl); #endif } /*****************************************************************************/ /* returns error, zero is ok */ int APP_CC g_chown(const char *name, int uid, int gid) { return chown(name, uid, gid); } /*****************************************************************************/ /* returns error, always zero */ int APP_CC g_mkdir(const char *dirname) { #if defined(_WIN32) return 0; #else return mkdir(dirname, S_IRWXU); #endif } /*****************************************************************************/ /* gets the current working directory and puts up to maxlen chars in dirname always returns 0 */ char *APP_CC g_get_current_dir(char *dirname, int maxlen) { #if defined(_WIN32) GetCurrentDirectoryA(maxlen, dirname); return 0; #else if (getcwd(dirname, maxlen) == 0) { } return 0; #endif } /*****************************************************************************/ /* returns error, zero on success and -1 on failure */ int APP_CC g_set_current_dir(const char *dirname) { #if defined(_WIN32) if (SetCurrentDirectoryA(dirname)) { return 0; } else { return -1; } #else return chdir(dirname); #endif } /*****************************************************************************/ /* returns boolean, non zero if the file exists */ int APP_CC g_file_exist(const char *filename) { #if defined(_WIN32) return 0; // use FileAge(filename) <> -1 #else return access(filename, F_OK) == 0; #endif } /*****************************************************************************/ /* returns boolean, non zero if the directory exists */ int APP_CC g_directory_exist(const char *dirname) { #if defined(_WIN32) return 0; // use GetFileAttributes and check return value // is not -1 and FILE_ATTRIBUTE_DIRECTORY bit is set #else struct stat st; if (stat(dirname, &st) == 0) { return S_ISDIR(st.st_mode); } else { return 0; } #endif } /*****************************************************************************/ /* returns boolean */ int APP_CC g_create_dir(const char *dirname) { #if defined(_WIN32) return CreateDirectoryA(dirname, 0); // test this #else return mkdir(dirname, (mode_t) - 1) == 0; #endif } /*****************************************************************************/ /* will try to create directories up to last / in name example /tmp/a/b/c/readme.txt will try to create /tmp/a/b/c returns boolean */ int APP_CC g_create_path(const char *path) { char *pp; char *sp; char *copypath; int status; status = 1; copypath = g_strdup(path); pp = copypath; sp = strchr(pp, '/'); while (sp != 0) { if (sp != pp) { *sp = 0; if (!g_directory_exist(copypath)) { if (!g_create_dir(copypath)) { status = 0; break; } } *sp = '/'; } pp = sp + 1; sp = strchr(pp, '/'); } g_free(copypath); return status; } /*****************************************************************************/ /* returns boolean */ int APP_CC g_remove_dir(const char *dirname) { #if defined(_WIN32) return RemoveDirectoryA(dirname); // test this #else return rmdir(dirname) == 0; #endif } /*****************************************************************************/ /* returns non zero if the file was deleted */ int APP_CC g_file_delete(const char *filename) { #if defined(_WIN32) return DeleteFileA(filename); #else return unlink(filename) != -1; #endif } /*****************************************************************************/ /* returns file size, -1 on error */ int APP_CC g_file_get_size(const char *filename) { #if defined(_WIN32) return -1; #else struct stat st; if (stat(filename, &st) == 0) { return (int)(st.st_size); } else { return -1; } #endif } /*****************************************************************************/ /* returns length of text */ int APP_CC g_strlen(const char *text) { if (text == NULL) { return 0; } return strlen(text); } /*****************************************************************************/ /* locates char in text */ const char *APP_CC g_strchr(const char* text, int c) { if (text == NULL) { return 0; } return strchr(text,c); } /*****************************************************************************/ /* returns dest */ char *APP_CC g_strcpy(char *dest, const char *src) { if (src == 0 && dest != 0) { dest[0] = 0; return dest; } if (dest == 0 || src == 0) { return 0; } return strcpy(dest, src); } /*****************************************************************************/ /* returns dest */ char *APP_CC g_strncpy(char *dest, const char *src, int len) { char *rv; if (src == 0 && dest != 0) { dest[0] = 0; return dest; } if (dest == 0 || src == 0) { return 0; } rv = strncpy(dest, src, len); dest[len] = 0; return rv; } /*****************************************************************************/ /* returns dest */ char *APP_CC g_strcat(char *dest, const char *src) { if (dest == 0 || src == 0) { return dest; } return strcat(dest, src); } /*****************************************************************************/ /* if in = 0, return 0 else return newly alloced copy of in */ char *APP_CC g_strdup(const char *in) { int len; char *p; if (in == 0) { return 0; } len = g_strlen(in); p = (char *)g_malloc(len + 1, 0); if (p != NULL) { g_strcpy(p, in); } return p; } /*****************************************************************************/ /* if in = 0, return 0 else return newly alloced copy of input string * if the input string is larger than maxlen the returned string will be * truncated. All strings returned will include null termination*/ char *APP_CC g_strndup(const char *in, const unsigned int maxlen) { unsigned int len; char *p; if (in == 0) { return 0; } len = g_strlen(in); if (len > maxlen) { len = maxlen - 1; } p = (char *)g_malloc(len + 2, 0); if (p != NULL) { g_strncpy(p, in, len + 1); } return p; } /*****************************************************************************/ int APP_CC g_strcmp(const char *c1, const char *c2) { return strcmp(c1, c2); } /*****************************************************************************/ int APP_CC g_strncmp(const char *c1, const char *c2, int len) { return strncmp(c1, c2, len); } /*****************************************************************************/ /* compare up to delim */ int APP_CC g_strncmp_d(const char *s1, const char *s2, const char delim, int n) { char c1; char c2; c1 = 0; c2 = 0; while (n > 0) { c1 = *(s1++); c2 = *(s2++); if ((c1 == 0) || (c1 != c2) || (c1 == delim) || (c2 == delim)) { return c1 - c2; } n--; } return c1 - c2; } /*****************************************************************************/ int APP_CC g_strcasecmp(const char *c1, const char *c2) { #if defined(_WIN32) return stricmp(c1, c2); #else return strcasecmp(c1, c2); #endif } /*****************************************************************************/ int APP_CC g_strncasecmp(const char *c1, const char *c2, int len) { #if defined(_WIN32) return strnicmp(c1, c2, len); #else return strncasecmp(c1, c2, len); #endif } /*****************************************************************************/ int APP_CC g_atoi(const char *str) { if (str == 0) { return 0; } return atoi(str); } /*****************************************************************************/ int APP_CC g_htoi(char *str) { int len; int index; int rv; int val; int shift; rv = 0; len = strlen(str); index = len - 1; shift = 0; while (index >= 0) { val = 0; switch (str[index]) { case '1': val = 1; break; case '2': val = 2; break; case '3': val = 3; break; case '4': val = 4; break; case '5': val = 5; break; case '6': val = 6; break; case '7': val = 7; break; case '8': val = 8; break; case '9': val = 9; break; case 'a': case 'A': val = 10; break; case 'b': case 'B': val = 11; break; case 'c': case 'C': val = 12; break; case 'd': case 'D': val = 13; break; case 'e': case 'E': val = 14; break; case 'f': case 'F': val = 15; break; } rv = rv | (val << shift); index--; shift += 4; } return rv; } /*****************************************************************************/ int APP_CC g_pos(const char *str, const char *to_find) { const char *pp; pp = strstr(str, to_find); if (pp == 0) { return -1; } return (pp - str); } /*****************************************************************************/ int APP_CC g_mbstowcs(twchar *dest, const char *src, int n) { wchar_t *ldest; int rv; ldest = (wchar_t *)dest; rv = mbstowcs(ldest, src, n); return rv; } /*****************************************************************************/ int APP_CC g_wcstombs(char *dest, const twchar *src, int n) { const wchar_t *lsrc; int rv; lsrc = (const wchar_t *)src; rv = wcstombs(dest, lsrc, n); return rv; } /*****************************************************************************/ /* returns error */ /* trim spaces and tabs, anything <= space */ /* trim_flags 1 trim left, 2 trim right, 3 trim both, 4 trim through */ /* this will always shorten the string or not change it */ int APP_CC g_strtrim(char *str, int trim_flags) { int index; int len; int text1_index; int got_char; wchar_t *text; wchar_t *text1; len = mbstowcs(0, str, 0); if (len < 1) { return 0; } if ((trim_flags < 1) || (trim_flags > 4)) { return 1; } text = (wchar_t *)malloc(len * sizeof(wchar_t) + 8); text1 = (wchar_t *)malloc(len * sizeof(wchar_t) + 8); text1_index = 0; mbstowcs(text, str, len + 1); switch (trim_flags) { case 4: /* trim through */ for (index = 0; index < len; index++) { if (text[index] > 32) { text1[text1_index] = text[index]; text1_index++; } } text1[text1_index] = 0; break; case 3: /* trim both */ got_char = 0; for (index = 0; index < len; index++) { if (got_char) { text1[text1_index] = text[index]; text1_index++; } else { if (text[index] > 32) { text1[text1_index] = text[index]; text1_index++; got_char = 1; } } } text1[text1_index] = 0; len = text1_index; /* trim right */ for (index = len - 1; index >= 0; index--) { if (text1[index] > 32) { break; } } text1_index = index + 1; text1[text1_index] = 0; break; case 2: /* trim right */ /* copy it */ for (index = 0; index < len; index++) { text1[text1_index] = text[index]; text1_index++; } /* trim right */ for (index = len - 1; index >= 0; index--) { if (text1[index] > 32) { break; } } text1_index = index + 1; text1[text1_index] = 0; break; case 1: /* trim left */ got_char = 0; for (index = 0; index < len; index++) { if (got_char) { text1[text1_index] = text[index]; text1_index++; } else { if (text[index] > 32) { text1[text1_index] = text[index]; text1_index++; got_char = 1; } } } text1[text1_index] = 0; break; } wcstombs(str, text1, text1_index + 1); free(text); free(text1); return 0; } /*****************************************************************************/ long APP_CC g_load_library(char *in) { #if defined(_WIN32) return (long)LoadLibraryA(in); #else return (long)dlopen(in, RTLD_LOCAL | RTLD_LAZY); #endif } /*****************************************************************************/ int APP_CC g_free_library(long lib) { if (lib == 0) { return 0; } #if defined(_WIN32) return FreeLibrary((HMODULE)lib); #else return dlclose((void *)lib); #endif } /*****************************************************************************/ /* returns NULL if not found */ void *APP_CC g_get_proc_address(long lib, const char *name) { if (lib == 0) { return 0; } #if defined(_WIN32) return GetProcAddress((HMODULE)lib, name); #else return dlsym((void *)lib, name); #endif } /*****************************************************************************/ /* does not work in win32 */ int APP_CC g_system(char *aexec) { #if defined(_WIN32) return 0; #else return system(aexec); #endif } /*****************************************************************************/ /* does not work in win32 */ char *APP_CC g_get_strerror(void) { #if defined(_WIN32) return 0; #else return strerror(errno); #endif } /*****************************************************************************/ int APP_CC g_get_errno(void) { #if defined(_WIN32) return GetLastError(); #else return errno; #endif } /*****************************************************************************/ /* does not work in win32 */ int APP_CC g_execvp(const char *p1, char *args[]) { #if defined(_WIN32) return 0; #else int rv; g_rm_temp_dir(); rv = execvp(p1, args); g_mk_temp_dir(0); return rv; #endif } /*****************************************************************************/ /* does not work in win32 */ int APP_CC g_execlp3(const char *a1, const char *a2, const char *a3) { #if defined(_WIN32) return 0; #else int rv; g_rm_temp_dir(); rv = execlp(a1, a2, a3, (void *)0); g_mk_temp_dir(0); return rv; #endif } /*****************************************************************************/ /* does not work in win32 */ void APP_CC g_signal_child_stop(void (*func)(int)) { #if defined(_WIN32) #else signal(SIGCHLD, func); #endif } /*****************************************************************************/ void APP_CC g_signal_segfault(void (*func)(int)) { #if defined(_WIN32) #else signal(SIGSEGV, func); #endif } /*****************************************************************************/ /* does not work in win32 */ void APP_CC g_signal_hang_up(void (*func)(int)) { #if defined(_WIN32) #else signal(SIGHUP, func); #endif } /*****************************************************************************/ /* does not work in win32 */ void APP_CC g_signal_user_interrupt(void (*func)(int)) { #if defined(_WIN32) #else signal(SIGINT, func); #endif } /*****************************************************************************/ /* does not work in win32 */ void APP_CC g_signal_terminate(void (*func)(int)) { #if defined(_WIN32) #else signal(SIGTERM, func); #endif } /*****************************************************************************/ /* does not work in win32 */ void APP_CC g_signal_pipe(void (*func)(int)) { #if defined(_WIN32) #else signal(SIGPIPE, func); #endif } /*****************************************************************************/ /* does not work in win32 */ void APP_CC g_signal_usr1(void (*func)(int)) { #if defined(_WIN32) #else signal(SIGUSR1, func); #endif } /*****************************************************************************/ /* does not work in win32 */ int APP_CC g_fork(void) { #if defined(_WIN32) return 0; #else int rv; rv = fork(); if (rv == 0) /* child */ { g_mk_temp_dir(0); } return rv; #endif } /*****************************************************************************/ /* does not work in win32 */ int APP_CC g_setgid(int pid) { #if defined(_WIN32) return 0; #else return setgid(pid); #endif } /*****************************************************************************/ /* returns error, zero is success, non zero is error */ /* does not work in win32 */ int APP_CC g_initgroups(const char *user, int gid) { #if defined(_WIN32) return 0; #else return initgroups(user, gid); #endif } /*****************************************************************************/ /* does not work in win32 */ /* returns user id */ int APP_CC g_getuid(void) { #if defined(_WIN32) return 0; #else return getuid(); #endif } /*****************************************************************************/ /* does not work in win32 */ /* returns user id */ int APP_CC g_getgid(void) { #if defined(_WIN32) return 0; #else return getgid(); #endif } /*****************************************************************************/ /* does not work in win32 */ /* On success, zero is returned. On error, -1 is returned */ int APP_CC g_setuid(int pid) { #if defined(_WIN32) return 0; #else return setuid(pid); #endif } /*****************************************************************************/ int APP_CC g_setsid(void) { #if defined(_WIN32) return -1; #else return setsid(); #endif } /*****************************************************************************/ int APP_CC g_setlogin(const char *name) { #ifdef BSD return setlogin(name); #else return -1; #endif } /*****************************************************************************/ /* does not work in win32 returns pid of process that exits or zero if signal occurred */ int APP_CC g_waitchild(void) { #if defined(_WIN32) return 0; #else int wstat; int rv; rv = waitpid(0, &wstat, WNOHANG); if (rv == -1) { if (errno == EINTR) /* signal occurred */ { rv = 0; } } return rv; #endif } /*****************************************************************************/ /* does not work in win32 returns pid of process that exits or zero if signal occurred */ int APP_CC g_waitpid(int pid) { #if defined(_WIN32) return 0; #else int rv = 0; if (pid < 0) { rv = -1; } else { rv = waitpid(pid, 0, 0); if (rv == -1) { if (errno == EINTR) /* signal occurred */ { rv = 0; } } } return rv; #endif } /*****************************************************************************/ /* does not work in win32 */ void APP_CC g_clearenv(void) { #if defined(_WIN32) #else #if defined(BSD) environ[0] = 0; #else environ = 0; #endif #endif } /*****************************************************************************/ /* does not work in win32 */ int APP_CC g_setenv(const char *name, const char *value, int rewrite) { #if defined(_WIN32) return 0; #else return setenv(name, value, rewrite); #endif } /*****************************************************************************/ /* does not work in win32 */ char *APP_CC g_getenv(const char *name) { #if defined(_WIN32) return 0; #else return getenv(name); #endif } /*****************************************************************************/ int APP_CC g_exit(int exit_code) { _exit(exit_code); return 0; } /*****************************************************************************/ int APP_CC g_getpid(void) { #if defined(_WIN32) return (int)GetCurrentProcessId(); #else return (int)getpid(); #endif } /*****************************************************************************/ /* does not work in win32 */ int APP_CC g_sigterm(int pid) { #if defined(_WIN32) return 0; #else return kill(pid, SIGTERM); #endif } /*****************************************************************************/ /* returns 0 if ok */ /* the caller is responsible to free the buffs */ /* does not work in win32 */ int APP_CC g_getuser_info(const char *username, int *gid, int *uid, char **shell, char **dir, char **gecos) { #if defined(_WIN32) return 1; #else struct passwd *pwd_1; pwd_1 = getpwnam(username); if (pwd_1 != 0) { if (gid != 0) { *gid = pwd_1->pw_gid; } if (uid != 0) { *uid = pwd_1->pw_uid; } if (dir != 0) { *dir = g_strdup(pwd_1->pw_dir); } if (shell != 0) { *shell = g_strdup(pwd_1->pw_shell); } if (gecos != 0) { *gecos = g_strdup(pwd_1->pw_gecos); } return 0; } return 1; #endif } /*****************************************************************************/ /* returns 0 if ok */ /* does not work in win32 */ int APP_CC g_getgroup_info(const char *groupname, int *gid) { #if defined(_WIN32) return 1; #else struct group *g; g = getgrnam(groupname); if (g != 0) { if (gid != 0) { *gid = g->gr_gid; } return 0; } return 1; #endif } /*****************************************************************************/ /* returns error */ /* if zero is returned, then ok is set */ /* does not work in win32 */ int APP_CC g_check_user_in_group(const char *username, int gid, int *ok) { #if defined(_WIN32) return 1; #else struct group *groups; int i; groups = getgrgid(gid); if (groups == 0) { return 1; } *ok = 0; i = 0; while (0 != groups->gr_mem[i]) { if (0 == g_strcmp(groups->gr_mem[i], username)) { *ok = 1; break; } i++; } return 0; #endif } /*****************************************************************************/ /* returns the time since the Epoch (00:00:00 UTC, January 1, 1970), measured in seconds. for windows, returns the number of seconds since the machine was started. */ int APP_CC g_time1(void) { #if defined(_WIN32) return GetTickCount() / 1000; #else return time(0); #endif } /*****************************************************************************/ /* returns the number of milliseconds since the machine was started. */ int APP_CC g_time2(void) { #if defined(_WIN32) return (int)GetTickCount(); #else struct tms tm; clock_t num_ticks = 0; g_memset(&tm, 0, sizeof(struct tms)); num_ticks = times(&tm); return (int)(num_ticks * 10); #endif } /*****************************************************************************/ /* returns time in milliseconds, uses gettimeofday does not work in win32 */ int APP_CC g_time3(void) { #if defined(_WIN32) return 0; #else struct timeval tp; gettimeofday(&tp, 0); return (tp.tv_sec * 1000) + (tp.tv_usec / 1000); #endif } /******************************************************************************/ /******************************************************************************/ struct bmp_magic { char magic[2]; }; struct bmp_hdr { unsigned int size; /* file size in bytes */ unsigned short reserved1; unsigned short reserved2; unsigned int offset; /* offset to image data, in bytes */ }; struct dib_hdr { unsigned int hdr_size; int width; int height; unsigned short nplanes; unsigned short bpp; unsigned int compress_type; unsigned int image_size; int hres; int vres; unsigned int ncolors; unsigned int nimpcolors; }; /******************************************************************************/ int APP_CC g_save_to_bmp(const char* filename, char* data, int stride_bytes, int width, int height, int depth, int bits_per_pixel) { struct bmp_magic bm; struct bmp_hdr bh; struct dib_hdr dh; int bytes; int fd; int index; int i1; int pixel; int extra; int file_stride_bytes; char* line; char* line_ptr; if ((depth == 24) && (bits_per_pixel == 32)) { } else if ((depth == 32) && (bits_per_pixel == 32)) { } else { g_writeln("g_save_to_bpp: unimp"); return 1; } bm.magic[0] = 'B'; bm.magic[1] = 'M'; /* scan lines are 32 bit aligned, bottom 2 bits must be zero */ file_stride_bytes = width * ((depth + 7) / 8); extra = file_stride_bytes; extra = extra & 3; extra = (4 - extra) & 3; file_stride_bytes += extra; bh.size = sizeof(bm) + sizeof(bh) + sizeof(dh) + height * file_stride_bytes; bh.reserved1 = 0; bh.reserved2 = 0; bh.offset = sizeof(bm) + sizeof(bh) + sizeof(dh); dh.hdr_size = sizeof(dh); dh.width = width; dh.height = height; dh.nplanes = 1; dh.bpp = depth; dh.compress_type = 0; dh.image_size = height * file_stride_bytes; dh.hres = 0xb13; dh.vres = 0xb13; dh.ncolors = 0; dh.nimpcolors = 0; fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR); if (fd == -1) { g_writeln("g_save_to_bpp: open error"); return 1; } bytes = write(fd, &bm, sizeof(bm)); if (bytes != sizeof(bm)) { g_writeln("g_save_to_bpp: write error"); } bytes = write(fd, &bh, sizeof(bh)); if (bytes != sizeof(bh)) { g_writeln("g_save_to_bpp: write error"); } bytes = write(fd, &dh, sizeof(dh)); if (bytes != sizeof(dh)) { g_writeln("g_save_to_bpp: write error"); } data += stride_bytes * height; data -= stride_bytes; if ((depth == 24) && (bits_per_pixel == 32)) { line = (char *) malloc(file_stride_bytes); memset(line, 0, file_stride_bytes); for (index = 0; index < height; index++) { line_ptr = line; for (i1 = 0; i1 < width; i1++) { pixel = ((int*)data)[i1]; *(line_ptr++) = (pixel >> 0) & 0xff; *(line_ptr++) = (pixel >> 8) & 0xff; *(line_ptr++) = (pixel >> 16) & 0xff; } bytes = write(fd, line, file_stride_bytes); if (bytes != file_stride_bytes) { g_writeln("g_save_to_bpp: write error"); } data -= stride_bytes; } free(line); } else if (depth == bits_per_pixel) { for (index = 0; index < height; index++) { bytes = write(fd, data, width * (bits_per_pixel / 8)); if (bytes != width * (bits_per_pixel / 8)) { g_writeln("g_save_to_bpp: write error"); } data -= stride_bytes; } } else { g_writeln("g_save_to_bpp: unimp"); } close(fd); return 0; } /*****************************************************************************/ /* returns boolean */ int APP_CC g_text2bool(const char *s) { if ( (g_atoi(s) != 0) || (0 == g_strcasecmp(s, "true")) || (0 == g_strcasecmp(s, "on")) || (0 == g_strcasecmp(s, "yes"))) { return 1; } return 0; } /*****************************************************************************/ /* returns pointer or nil on error */ void * APP_CC g_shmat(int shmid) { #if defined(_WIN32) return 0; #else return shmat(shmid, 0, 0); #endif } /*****************************************************************************/ /* returns -1 on error 0 on success */ int APP_CC g_shmdt(const void *shmaddr) { #if defined(_WIN32) return -1; #else return shmdt(shmaddr); #endif } /*****************************************************************************/ /* returns -1 on error 0 on success */ int APP_CC g_gethostname(char *name, int len) { return gethostname(name, len); } static unsigned char g_reverse_byte[0x100] = { 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0, 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4, 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6, 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1, 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd, 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3, 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7, 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff }; /*****************************************************************************/ /* mirror each byte while copying */ int APP_CC g_mirror_memcpy(void *dst, const void *src, int len) { tui8 *dst8; const tui8 *src8; dst8 = (tui8 *) dst; src8 = (const tui8 *) src; while (len > 0) { *dst8 = g_reverse_byte[*src8]; dst8++; src8++; len--; } return 0; }