[Pkg-remote-team] [xrdp] 02/04: sync master for tcp_proxy
Dominik George
natureshadow-guest at moszumanska.debian.org
Sat Nov 26 10:59:49 UTC 2016
This is an automated email from the git hooks/post-receive script.
natureshadow-guest pushed a commit to annotated tag v0.6.0
in repository xrdp.
commit faed9f246dc24e9d7d2625ab37bdd5a4778b2d42
Author: Jay Sorg <jay.sorg at gmail.com>
Date: Sat Feb 18 23:29:00 2012 -0800
sync master for tcp_proxy
---
xorg/tests/tcp_proxy/main.c | 10 +-
xorg/tests/tcp_proxy/os_calls.c | 1449 ---------------------------------------
xorg/tests/tcp_proxy/os_calls.h | 208 ------
3 files changed, 5 insertions(+), 1662 deletions(-)
diff --git a/xorg/tests/tcp_proxy/main.c b/xorg/tests/tcp_proxy/main.c
index 7bfc747..0e6f4fe 100644
--- a/xorg/tests/tcp_proxy/main.c
+++ b/xorg/tests/tcp_proxy/main.c
@@ -238,11 +238,11 @@ main(int argc, char** argv)
usage();
return 0;
}
- g_init();
- g_signal(2, proxy_shutdown); /* SIGINT */
- g_signal(9, proxy_shutdown); /* SIGKILL */
- g_signal(10, clear_counters);/* SIGUSR1*/
- g_signal(15, proxy_shutdown);/* SIGTERM */
+ g_init("tcp_proxy");
+ g_signal_user_interrupt(proxy_shutdown); /* SIGINT */
+ g_signal_kill(proxy_shutdown); /* SIGKILL */
+ g_signal_usr1(clear_counters); /* SIGUSR1*/
+ g_signal_terminate(proxy_shutdown); /* SIGTERM */
if (argc < 5)
{
while (!g_terminated)
diff --git a/xorg/tests/tcp_proxy/os_calls.c b/xorg/tests/tcp_proxy/os_calls.c
deleted file mode 100644
index b17856b..0000000
--- a/xorg/tests/tcp_proxy/os_calls.c
+++ /dev/null
@@ -1,1449 +0,0 @@
-/*
- Copyright (c) 2004-2007 Jay Sorg
-
- Permission is hereby granted, free of charge, to any person obtaining a
- copy of this software and associated documentation files (the "Software"),
- to deal in the Software without restriction, including without limitation
- the rights to use, copy, modify, merge, publish, distribute, sublicense,
- and/or sell copies of the Software, and to permit persons to whom the
- Software is furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included
- in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- DEALINGS IN THE SOFTWARE.
-
- generic operating system calls
-
- put all the os / arch define in here you want
-*/
-
-#if defined(_WIN32)
-#include <windows.h>
-#include <winsock.h>
-#else
-/* fix for solaris 10 with gcc 3.3.2 problem */
-#if defined(sun) || defined(__sun)
-#define ctid_t id_t
-#endif
-#include <unistd.h>
-#include <errno.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <sys/stat.h>
-#include <dlfcn.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <signal.h>
-#include <fcntl.h>
-#include <pwd.h>
-#include <time.h>
-#include <grp.h>
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdarg.h>
-#include <stdio.h>
-
-#include "os_calls.h"
-#include "arch.h"
-
-/* for clearenv() */
-#if defined(_WIN32)
-#else
-extern char** environ;
-#endif
-
-/* for solaris */
-#if !defined(PF_LOCAL)
-#define PF_LOCAL AF_UNIX
-#endif
-#if !defined(INADDR_NONE)
-#define INADDR_NONE ((unsigned long)-1)
-#endif
-
-/*****************************************************************************/
-void APP_CC
-g_init(void)
-{
- #if defined(_WIN32)
- WSADATA wsadata;
-
- WSAStartup(2, &wsadata);
- #endif
-}
-
-
-/*****************************************************************************/
-void APP_CC
-g_deinit(void)
-{
- #if defined(_WIN32)
- WSACleanup();
- #endif
-}
-
-
-/*****************************************************************************/
-/* 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)
- {
- 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);
-}
-
-
-/*****************************************************************************/
-void DEFAULT_CC
-g_snprintf(char* dest, int len, const char* format, ...)
-{
- va_list ap;
-
- va_start(ap, format);
- vsnprintf(dest, len, format, ap);
- va_end(ap);
-}
-
-
-/*****************************************************************************/
-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("");
- 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();
-}
-
-
-/*****************************************************************************/
-int APP_CC
-g_tcp_set_no_delay(int sck)
-{
- int i;
-
- i = 1;
- #if defined(_WIN32)
- setsockopt(sck, IPPROTO_TCP, TCP_NODELAY, (char*)&i, sizeof(i));
- #else
- setsockopt(sck, IPPROTO_TCP, TCP_NODELAY, (void*)&i, sizeof(i));
- #endif
- return 0;
-}
-
-
-/*****************************************************************************/
-int APP_CC
-g_tcp_socket(void)
-{
- int rv;
- int i;
-
- rv = socket(PF_INET, SOCK_STREAM, 0);
- #if defined(_WIN32)
- i = 1;
- setsockopt(rv, IPPROTO_TCP, TCP_NODELAY, (char*)&i, sizeof(i));
- i = 1;
- setsockopt(rv, SOL_SOCKET, SO_REUSEADDR, (char*)&i, sizeof(i));
- i = 8192 * 2;
- setsockopt(rv, SOL_SOCKET, SO_SNDBUF, (char*)&i, sizeof(i));
- #else
- i = 1;
- setsockopt(rv, IPPROTO_TCP, TCP_NODELAY, (void*)&i, sizeof(i));
- i = 1;
- setsockopt(rv, SOL_SOCKET, SO_REUSEADDR, (void*)&i, sizeof(i));
- i = 8192 * 2;
- setsockopt(rv, SOL_SOCKET, SO_SNDBUF, (void*)&i, sizeof(i));
- #endif
- return rv;
-}
-
-
-/*****************************************************************************/
-int APP_CC
-g_tcp_local_socket(void)
-{
- #if defined(_WIN32)
- return 0;
- #else
- return socket(PF_LOCAL, SOCK_STREAM, 0);
- #endif
-}
-
-
-/*****************************************************************************/
-void APP_CC
-g_tcp_close(int sck)
-{
- if (sck == 0)
- {
- return;
- }
- shutdown(sck, 2);
- #if defined(_WIN32)
- closesocket(sck);
- #else
- close(sck);
- #endif
-}
-
-
-/*****************************************************************************/
-int APP_CC
-g_tcp_connect(int sck, const char* address, const char* port)
-{
- struct sockaddr_in s;
- struct hostent* h;
-
- g_memset(&s, 0, sizeof(struct sockaddr_in));
- s.sin_family = AF_INET;
- s.sin_port = htons(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)));
- }
- }
- }
- }
- }
- return connect(sck, (struct sockaddr*)&s, sizeof(struct sockaddr_in));
-}
-
-
-/*****************************************************************************/
-int APP_CC
-g_tcp_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;
- fcntl(sck, F_SETFL, i);
- #endif
- return 0;
-}
-
-
-/*****************************************************************************/
-int APP_CC
-g_tcp_bind(int sck, char* port)
-{
- struct sockaddr_in s;
-
- memset(&s, 0, sizeof(struct sockaddr_in));
- s.sin_family = AF_INET;
- s.sin_port = htons(atoi(port));
- s.sin_addr.s_addr = INADDR_ANY;
- return bind(sck, (struct sockaddr*)&s, sizeof(struct sockaddr_in));
-}
-
-
-/*****************************************************************************/
-int APP_CC
-g_tcp_local_bind(int sck, char* port)
-{
- #if defined(_WIN32)
- return -1;
- #else
- struct sockaddr_un s;
-
- memset(&s, 0, sizeof(struct sockaddr_un));
- s.sun_family = AF_UNIX;
- strcpy(s.sun_path, port);
- return bind(sck, (struct sockaddr*)&s, sizeof(struct sockaddr_un));
- #endif
-}
-
-
-/*****************************************************************************/
-int APP_CC
-g_tcp_listen(int sck)
-{
- return listen(sck, 2);
-}
-
-
-/*****************************************************************************/
-int APP_CC
-g_tcp_accept(int sck)
-{
- struct sockaddr_in s;
- #if defined(_WIN32)
- signed int i;
- #else
- unsigned int i;
- #endif
-
- i = sizeof(struct sockaddr_in);
- memset(&s, 0, i);
- return accept(sck, (struct sockaddr*)&s, &i);
-}
-
-
-/*****************************************************************************/
-void APP_CC
-g_sleep(int msecs)
-{
- #if defined(_WIN32)
- Sleep(msecs);
- #else
- usleep(msecs * 1000);
- #endif
-}
-
-
-/*****************************************************************************/
-int APP_CC
-g_tcp_last_error_would_block(int sck)
-{
- #if defined(_WIN32)
- return WSAGetLastError() == WSAEWOULDBLOCK;
- #else
- return (errno == EWOULDBLOCK) || (errno == EINPROGRESS);
- #endif
-}
-
-
-/*****************************************************************************/
-int APP_CC
-g_tcp_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_tcp_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
-}
-
-
-/*****************************************************************************/
-/* wait 'millis' milliseconds for the socket to be able to write */
-/* returns boolean */
-int APP_CC
-g_tcp_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_tcp_can_recv(int sck, int millis)
-{
- fd_set rfds;
- struct timeval time;
- int rv;
-
- 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_tcp_select(int sck1, int sck2)
-{
- fd_set rfds;
- struct timeval time;
- int max;
- int rv;
-
- time.tv_sec = 0;
- time.tv_usec = 0;
- 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;
-}
-
-
-/*****************************************************************************/
-void APP_CC
-g_random(char* data, int len)
-{
- #if defined(_WIN32)
- memset(data, 0x44, len);
- #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)
- {
- read(fd, data, 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)CreateFile(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 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 writen or -1 on error */
-int APP_CC
-g_file_write(int fd, 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, always zero */
-int APP_CC
-g_set_file_rights(const char* filename, int read, int write)
-{
- #if defined(_WIN32)
- return 0;
- #else
- int flags;
-
- flags = read ? S_IRUSR : 0;
- flags |= write ? S_IWUSR : 0;
- chmod(filename, flags);
- return 0;
- #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, always zero */
-int APP_CC
-g_mkdir(const char* dirname)
-{
- #if defined(_WIN32)
- return 0;
- #else
- mkdir(dirname, S_IRWXU);
- return 0;
- #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)
- GetCurrentDirectory(maxlen, dirname);
- return 0;
- #else
- getcwd(dirname, maxlen);
- return 0;
- #endif
-}
-
-
-/*****************************************************************************/
-/* returns error, zero on success and -1 on failure */
-int APP_CC
-g_set_current_dir(char* dirname)
-{
- #if defined(_WIN32)
- if (SetCurrentDirectory(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_ATTRIBUT_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)
- // test this
- return CreateDirectory(dirname, 0);
- #else
- return mkdir(dirname, (mode_t)-1) == 0;
- #endif
-}
-
-
-/*****************************************************************************/
-/* returns boolean */
-int APP_CC
-g_remove_dir(const char* dirname)
-{
- #if defined(_WIN32)
- // test this
- return RemoveDirectory(dirname);
- #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 DeleteFile(filename);
- #else
- return unlink(filename) != -1;
- #endif
-}
-
-
-/*****************************************************************************/
-/* returns length of text */
-int APP_CC
-g_strlen(const char* text)
-{
- if (text == 0)
- {
- return 0;
- }
- return strlen(text);
-}
-
-
-/*****************************************************************************/
-/* 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;
- }
... 701 lines suppressed ...
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-remote/packages/xrdp.git
More information about the Pkg-remote-team
mailing list