wolfhelm/server
1
0
Fork 0
forked from metin2/server
Code Pull Requests Activity

Add project files.

Browse Source
This commit is contained in:
Exynox
2022-03-05 12:44:06 +02:00
parent 453a74459f
commit f4f90b2533
517 changed files with 195610 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
libthecore/CMakeLists.txt Normal file
View File

@ -0,0 +1,24 @@
cmake_minimum_required(VERSION 2.8)
project(libthecore C)
# Find source files
file(GLOB SOURCES
"src/*.c"
"include/*.h"
)
# Include header files
include_directories("include")
# Create shared library
add_library(${PROJECT_NAME} STATIC ${SOURCES})
# Find dependencies
find_package(Boost REQUIRED)
# Link dependencies if found
if (Boost_FOUND)
include_directories(${Boost_INCLUDE_DIRS})
target_link_libraries (${PROJECT_NAME} ${Boost_LIBRARIES})
endif (Boost_FOUND)

57
libthecore/include/buffer.h Normal file
View File

@ -0,0 +1,57 @@
/*
* Filename: buffer.h
* Description: Buffer ó<><C3B3> <20><><EFBFBD><EFBFBD>
*
* Author: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (aka. <20><><EFBFBD><EFBFBD>, Cronan), <20>ۿ<EFBFBD><DBBF><EFBFBD> (aka. myevan, <20><><EFBFBD>ڷ<EFBFBD>)
*/
#ifndef __INC_LIBTHECORE_BUFFER_H__
#define __INC_LIBTHECORE_BUFFER_H__
#define SAFE_BUFFER_DELETE(buf) { if(buf != NULL) { buffer_delete(buf); buf = NULL; } }
typedef struct buffer BUFFER;
typedef struct buffer * LPBUFFER;
struct buffer
{
struct buffer * next;
char * write_point;
int write_point_pos;
const char * read_point;
int length;
char * mem_data;
int mem_size;
long flag;
};
extern LPBUFFER buffer_new(int size); // <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
extern void buffer_delete(LPBUFFER buffer); // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
extern void buffer_reset(LPBUFFER buffer); // <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̵<EFBFBD><CCB5><EFBFBD> <20>ʱ<EFBFBD>ȭ
extern DWORD buffer_size(LPBUFFER buffer); // <20><><EFBFBD>ۿ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
extern int buffer_has_space(LPBUFFER buffer); // <20><> <20><> <20>ִ<EFBFBD> <20><><EFBFBD≯<EFBFBD> <20><><EFBFBD><EFBFBD>
extern void buffer_write (LPBUFFER& buffer, const void* src, int length); // <20><><EFBFBD>ۿ<EFBFBD> <20><><EFBFBD><EFBFBD>.
extern void buffer_read(LPBUFFER buffer, void * buf, int bytes); // <20><><EFBFBD>ۿ<EFBFBD><DBBF><EFBFBD> <20>д´<D0B4>.
extern BYTE buffer_get_byte(LPBUFFER buffer);
extern WORD buffer_get_word(LPBUFFER buffer);
extern DWORD buffer_get_dword(LPBUFFER buffer);
// buffer_proceed <20>Լ<EFBFBD><D4BC><EFBFBD> buffer_peek<65><6B><EFBFBD><EFBFBD> <20>б<EFBFBD><D0B1><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD> <20><><EFBFBD><EFBFBD> <20>޾Ƽ<DEBE> <20><> <20>ʿ䰡
// <20><><EFBFBD><EFBFBD> <20><> ó<><C3B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>󸶳<EFBFBD> ó<><C3B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ٰ<EFBFBD> <20>뺸<EFBFBD>ؾ<EFBFBD> <20><> <20><> <20><><EFBFBD><EFBFBD>.
// (buffer_read, buffer_get_* <20>ø<EFBFBD><C3B8><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>쿡<EFBFBD><ECBFA1> <20>˾Ƽ<CBBE> ó<><C3B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> peek<65><6B><EFBFBD><EFBFBD> ó<><C3B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD><EFBFBD> <20>׷<EFBFBD><D7B7><EFBFBD> <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD>)
extern const void * buffer_read_peek(LPBUFFER buffer); // <20>д<EFBFBD> <20><>ġ<EFBFBD><C4A1> <20><><EFBFBD><EFBFBD>
extern void buffer_read_proceed(LPBUFFER buffer, int length); // length<74><68>ŭ<EFBFBD><C5AD> ó<><C3B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> write_peek<65><6B><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ġ<EFBFBD><C4A1> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>󸶳<EFBFBD> <20>質 <20>뺸<EFBFBD><EBBAB8> <20><>
// buffer_write_proceed<65><64> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
extern void * buffer_write_peek(LPBUFFER buffer); // <20><><EFBFBD><EFBFBD> <20><>ġ<EFBFBD><C4A1> <20><><EFBFBD><EFBFBD>
extern void buffer_write_proceed(LPBUFFER buffer, int length); // length<74><68> <20><><EFBFBD><EFBFBD> <20><>Ų<EFBFBD><C5B2>.
extern void buffer_adjust_size(LPBUFFER & buffer, int add_size); // add_size<7A><65>ŭ <20>߰<EFBFBD><DFB0><EFBFBD> ũ<>⸦ Ȯ<><C8AE>
#endif

23
libthecore/include/crypt.h Normal file
View File

@ -0,0 +1,23 @@
#ifdef __cplusplus
extern "C" {
#endif
/* TEA is a 64-bit symmetric block cipher with a 128-bit key, developed
by David J. Wheeler and Roger M. Needham, and described in their
paper at <URL:http://www.cl.cam.ac.uk/ftp/users/djw3/tea.ps>.
This implementation is based on their code in
<URL:http://www.cl.cam.ac.uk/ftp/users/djw3/xtea.ps> */
extern int TEA_Encrypt(DWORD *dest, const DWORD *src, const DWORD *key, int size);
extern int TEA_Decrypt(DWORD *dest, const DWORD *src, const DWORD *key, int size);
extern int GOST_Encrypt(DWORD * DstBuffer, const DWORD * SrcBuffer, const DWORD * KeyAddress, DWORD Length, DWORD *IVector);
extern int GOST_Decrypt(DWORD * DstBuffer, const DWORD * SrcBuffer, const DWORD * KeyAddress, DWORD Length, DWORD *IVector);
extern int DES_Encrypt(DWORD *DstBuffer, const DWORD * SrcBuffer, const DWORD *KeyAddress, DWORD Length, DWORD *IVector);
extern int DES_Decrypt(DWORD *DstBuffer, const DWORD * SrcBuffer, const DWORD *KeyAddress, DWORD Length, DWORD *IVector);
#ifdef __cplusplus
};
#endif

95
libthecore/include/fdwatch.h Normal file
View File

@ -0,0 +1,95 @@
#ifndef __INC_LIBTHECORE_FDWATCH_H__
#define __INC_LIBTHECORE_FDWATCH_H__
#ifndef __WIN32__
typedef struct fdwatch FDWATCH;
typedef struct fdwatch * LPFDWATCH;
enum EFdwatch
{
FDW_NONE = 0,
FDW_READ = 1,
FDW_WRITE = 2,
FDW_WRITE_ONESHOT = 4,
FDW_EOF = 8,
};
typedef struct kevent KEVENT;
typedef struct kevent * LPKEVENT;
typedef int KQUEUE;
struct fdwatch
{
KQUEUE kq;
int nfiles;
LPKEVENT kqevents;
int nkqevents;
LPKEVENT kqrevents;
int * fd_event_idx;
void ** fd_data;
int * fd_rw;
};
#else
typedef struct fdwatch FDWATCH;
typedef struct fdwatch * LPFDWATCH;
enum EFdwatch
{
FDW_NONE = 0,
FDW_READ = 1,
FDW_WRITE = 2,
FDW_WRITE_ONESHOT = 4,
FDW_EOF = 8,
};
struct fdwatch
{
fd_set rfd_set;
fd_set wfd_set;
socket_t* select_fds;
int* select_rfdidx;
int nselect_fds;
fd_set working_rfd_set;
fd_set working_wfd_set;
int nfiles;
void** fd_data;
int* fd_rw;
};
#endif // WIN32
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
extern LPFDWATCH fdwatch_new(int nfiles);
extern void fdwatch_clear_fd(LPFDWATCH fdw, socket_t fd);
extern void fdwatch_delete(LPFDWATCH fdw);
extern int fdwatch_check_fd(LPFDWATCH fdw, socket_t fd);
extern int fdwatch_check_event(LPFDWATCH fdw, socket_t fd, unsigned int event_idx);
extern void fdwatch_clear_event(LPFDWATCH fdw, socket_t fd, unsigned int event_idx);
extern void fdwatch_add_fd(LPFDWATCH fdw, socket_t fd, void* client_data, int rw, int oneshot);
extern int fdwatch(LPFDWATCH fdw, struct timeval *timeout);
extern void * fdwatch_get_client_data(LPFDWATCH fdw, unsigned int event_idx);
extern void fdwatch_del_fd(LPFDWATCH fdw, socket_t fd);
extern int fdwatch_get_buffer_size(LPFDWATCH fdw, socket_t fd);
extern int fdwatch_get_ident(LPFDWATCH fdw, unsigned int event_idx);
#ifdef __cplusplus
}
#endif
#endif

31
libthecore/include/hangul.h Normal file
View File

@ -0,0 +1,31 @@
#ifndef __INC_LIBTHECORE_HANGUL_H__
#define __INC_LIBTHECORE_HANGUL_H__
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#ifdef __WIN32__
#define isdigit iswdigit
#define isspace iswspace
#endif
#define ishan(ch) (((ch) & 0xE0) > 0x90)
#define ishanasc(ch) (isascii(ch) || ishan(ch))
#define ishanalp(ch) (isalpha(ch) || ishan(ch))
#define isnhdigit(ch) (!ishan(ch) && isdigit(ch))
#define isnhspace(ch) (!ishan(ch) && isspace(ch))
extern const char * first_han(const BYTE * str); // ù<><C3B9>° <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)<29><> <20>̾<EFBFBD> <20><>/<2F><>/<2F><>/..<2E><> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
extern int check_han(const char * str); // <20>ѱ<EFBFBD><D1B1≯<EFBFBD> true <20><>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD> üũ
extern int is_hangul(const BYTE * str); // <20>ѱ<EFBFBD><D1B1≯<EFBFBD> true (2<><32><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> üũ)
extern int under_han(const void * orig); // <20><>ħ<EFBFBD><C4A7> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> true
#define UNDER(str) under_han(str)
#ifdef __cplusplus
};
#endif
#endif

26
libthecore/include/heart.h Normal file
View File

@ -0,0 +1,26 @@
#ifndef __INC_LIBTHECORE_HEART_H__
#define __INC_LIBTHECORE_HEART_H__
typedef struct heart HEART;
typedef struct heart * LPHEART;
typedef void (*HEARTFUNC) (LPHEART heart, int pulse);
struct heart
{
HEARTFUNC func;
struct timeval before_sleep;
struct timeval opt_time;
struct timeval last_time;
int passes_per_sec;
int pulse;
};
extern LPHEART heart_new(int opt_usec, HEARTFUNC func);
extern void heart_delete(LPHEART ht);
extern int heart_idle(LPHEART ht); // <20><> pulse<73><65> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
extern void heart_beat(LPHEART ht, int pulses);
#endif

10
libthecore/include/kstbl.h Normal file
View File

@ -0,0 +1,10 @@
/*
* Filename: kstbl.h
* Description: KS <20>ϼ<EFBFBD><CFBC><EFBFBD> 2350<35><30><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ڵ<EFBFBD>
*
* Author: <20><><EFBFBD><EFBFBD> (server), myevan (Client)
*/
#ifndef __KSTBL_H__
#define __KSTBL_H__
extern unsigned KStbl[2350];
#endif

39
libthecore/include/log.h Normal file
View File

@ -0,0 +1,39 @@
#ifndef __INC_LIBTHECORE_LOG_H__
#define __INC_LIBTHECORE_LOG_H__
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
extern int log_init(void);
extern void log_destroy(void);
extern void log_rotate(void);
// <20>α<EFBFBD> <20><><EFBFBD><EFBFBD> ó<><C3B3> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> bitvector<6F><72> ó<><C3B3><EFBFBD>ȴ<EFBFBD>)
extern void log_set_level(unsigned int level);
extern void log_unset_level(unsigned int level);
// <20>α<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ŭ <20><><EFBFBD><EFBFBD><EFBFBD>ϴ°<CFB4><C2B0><EFBFBD> <20><><EFBFBD><EFBFBD> <20>Լ<EFBFBD>
extern void log_set_expiration_days(unsigned int days);
extern int log_get_expiration_days(void);
#ifndef __WIN32__
extern void _sys_err(const char *func, int line, const char *format, ...);
#else
extern void _sys_err(const char *func, int line, const char *format, ...);
#endif
extern void sys_log_header(const char *header);
extern void sys_log(unsigned int lv, const char *format, ...);
extern void pt_log(const char *format, ...);
#ifndef __WIN32__
#define sys_err(fmt, args...) _sys_err(__FUNCTION__, __LINE__, fmt, ##args)
#else
#define sys_err(fmt, ...) _sys_err(__FUNCTION__, __LINE__, fmt, __VA_ARGS__)
#endif // __WIN32__
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // __INC_LOG_H__

40
libthecore/include/main.h Normal file
View File

@ -0,0 +1,40 @@
#ifndef __INC_LIBTHECORE_MAIN_H__
#define __INC_LIBTHECORE_MAIN_H__
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#ifdef __LIBTHECORE__
extern volatile int tics;
extern volatile int shutdowned;
#endif
#include "heart.h"
extern LPHEART thecore_heart;
enum ENUM_PROFILER
{
PF_IDLE,
PF_HEARTBEAT,
NUM_PF
};
extern unsigned int thecore_profiler[NUM_PF];
extern int thecore_init(int fps, HEARTFUNC heartbeat_func);
extern int thecore_idle(void);
extern void thecore_shutdown(void);
extern void thecore_destroy(void);
extern int thecore_pulse(void);
extern float thecore_time(void);
extern float thecore_pulse_per_second(void);
extern int thecore_is_shutdowned(void);
extern void thecore_tick(void); // tics <20><><EFBFBD><EFBFBD>
#ifdef __cplusplus
}
#endif
#endif

23
libthecore/include/memcpy.h Normal file
View File

@ -0,0 +1,23 @@
#ifndef __INC_LIBTHECORE_MEMCPY_H__
#define __INC_LIBTHECORE_MEMCPY_H__
#ifdef __cplusplus
extern "C"
{
#endif
#ifdef __LIBTHECORE__
void thecore_find_best_memcpy();
#endif
#ifndef __WIN32__
extern void *(*thecore_memcpy) (void * to, const void * from, size_t len);
#else
#include <cstring>
#define thecore_memcpy memcpy
#endif
#ifdef __cplusplus
};
#endif
#endif

16
libthecore/include/signal.h Normal file
View File

@ -0,0 +1,16 @@
#ifndef __INC_LIBTHECORE_SIGNAL_H__
#define __INC_LIBTHECORE_SIGNAL_H__
#ifdef __cplusplus
extern "C"
{
#endif
extern void signal_setup();
extern void signal_timer_disable();
extern void signal_timer_enable(int timeout_seconds);
#ifdef __cplusplus
};
#endif
#endif

45
libthecore/include/socket.h Normal file
View File

@ -0,0 +1,45 @@
/*
* Filename: socket.c
* Description: <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>Լ<EFBFBD> <20><><EFBFBD><EFBFBD>.
*
* Author: <20><><EFBFBD><EFBFBD> (server), myevan (Client)
*/
#ifndef __INC_LIBTHECORE_SOCKET_H__
#define __INC_LIBTHECORE_SOCKET_H__
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#ifdef __WIN32__
typedef int socklen_t;
#else
#define INVALID_SOCKET -1
#endif
extern int socket_read(socket_t desc, char* read_point, size_t space_left);
extern int socket_write(socket_t desc, const char *data, size_t length);
extern int socket_udp_read(socket_t desc, char * read_point, size_t space_left, struct sockaddr * from, socklen_t * fromlen);
extern int socket_tcp_bind(const char * ip, int port);
extern int socket_udp_bind(const char * ip, int port);
extern socket_t socket_accept(socket_t s, struct sockaddr_in *peer);
extern void socket_close(socket_t s);
extern socket_t socket_connect(const char* host, WORD port);
extern void socket_nonblock(socket_t s);
extern void socket_block(socket_t s);
extern void socket_dontroute(socket_t s);
extern void socket_lingeroff(socket_t s);
extern void socket_lingeron(socket_t s);
extern void socket_sndbuf(socket_t s, unsigned int opt);
extern void socket_rcvbuf(socket_t s, unsigned int opt);
#ifdef __cplusplus
};
#endif
#endif

145
libthecore/include/stdafx.h Normal file
View File

@ -0,0 +1,145 @@
#ifndef __INC_LIBTHECORE_STDAFX_H__
#define __INC_LIBTHECORE_STDAFX_H__
#if defined(__GNUC__)
#define INLINE __inline__
#elif defined(_MSC_VER)
#define INLINE inline
#endif
#ifdef __WIN32__
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <winsock2.h>
#include <tchar.h>
#include <errno.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <conio.h>
#include <process.h>
#include <limits.h>
#include <math.h>
#include <locale.h>
#include <io.h>
#include <direct.h>
#include <fcntl.h>
#include "xdirent.h"
#include "xgetopt.h"
#define S_ISDIR(m) (m & _S_IFDIR)
#define snprintf _snprintf
struct timespec
{
time_t tv_sec; /* seconds */
long tv_nsec; /* and nanoseconds */
};
#define __USE_SELECT__
#define PATH_MAX _MAX_PATH
// C runtime library adjustments
#define strlcat(dst, src, size) strcat_s(dst, size, src)
#define strlcpy(dst, src, size) strncpy_s(dst, size, src, _TRUNCATE)
#define strtoull(str, endptr, base) _strtoui64(str, endptr, base)
#define strtof(str, endptr) (float)strtod(str, endptr)
#define strcasecmp(s1, s2) stricmp(s1, s2)
#define strncasecmp(s1, s2, n) strnicmp(s1, s2, n)
#define atoll(str) _atoi64(str)
#define localtime_r(timet, result) localtime_s(result, timet)
#define strtok_r(s, delim, ptrptr) strtok_s(s, delim, ptrptr)
#include <boost/typeof/typeof.hpp>
#define typeof(t) BOOST_TYPEOF(t)
// dummy declaration of non-supported signals
#define SIGUSR1 30 /* user defined signal 1 */
#define SIGUSR2 31 /* user defined signal 2 */
inline void usleep(unsigned long usec) {
::Sleep(usec / 1000);
}
inline unsigned sleep(unsigned sec) {
::Sleep(sec * 1000);
return 0;
}
inline double rint(double x)
{
return ::floor(x+.5);
}
#else
#ifndef __FreeBSD__
#define __USE_SELECT__
#ifdef __CYGWIN__
#define _POSIX_SOURCE 1
#endif
#endif
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <dirent.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/socket.h>
#include <sys/signal.h>
#include <sys/wait.h>
#include <pthread.h>
#include <semaphore.h>
#ifdef __FreeBSD__
#include <sys/event.h>
#endif
#endif
#ifndef false
#define false 0
#define true (!false)
#endif
#ifndef FALSE
#define FALSE false
#define TRUE (!FALSE)
#endif
#include "typedef.h"
#include "heart.h"
#include "fdwatch.h"
#include "socket.h"
#include "kstbl.h"
#include "hangul.h"
#include "buffer.h"
#include "signal.h"
#include "log.h"
#include "main.h"
#include "utils.h"
#include "crypt.h"
#include "memcpy.h"
#endif // __INC_LIBTHECORE_STDAFX_H__

62
libthecore/include/typedef.h Normal file
View File

@ -0,0 +1,62 @@
#ifndef __INC_LIBTHECORE_TYPEDEF_H__
#define __INC_LIBTHECORE_TYPEDEF_H__
typedef unsigned long int QWORD;
typedef unsigned char UBYTE;
typedef signed char sbyte;
typedef unsigned short sh_int;
#ifndef __WIN32__
#ifndef __cplusplus
typedef unsigned char bool;
#endif
typedef unsigned int DWORD;
typedef int BOOL;
typedef unsigned char BYTE;
typedef unsigned short WORD;
typedef long LONG;
typedef unsigned long ULONG;
typedef int INT;
typedef unsigned int UINT;
typedef int socket_t;
#else
struct timezone
{
int tz_minuteswest; /* minutes west of Greenwich */
int tz_dsttime; /* type of dst correction */
};
typedef SOCKET socket_t;
#if !defined(_W64)
#if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
#define _W64 __w64
#else
#define _W64
#endif
#endif
#ifdef _WIN64
typedef __int64 ssize_t;
#else
typedef _W64 int ssize_t;
#endif
// Fixed-size integer types
#if defined(_MSC_VER) && (_MSC_VER >= 1300)
typedef __int32 int32_t;
typedef unsigned __int32 uint32_t;
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;
#endif
typedef unsigned int uint;
#endif
#endif // __INC_LIBTHECORE_TYPEDEF_H__

152
libthecore/include/utils.h Normal file
View File

@ -0,0 +1,152 @@
#ifndef __INC_LIBTHECORE_UTILS_H__
#define __INC_LIBTHECORE_UTILS_H__
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#define SAFE_FREE(p) { if (p) { free( (void *) p); (p) = NULL; } }
#define SAFE_DELETE(p) { if (p) { delete (p); (p) = NULL; } }
#define SAFE_DELETE_ARRAY(p) { if (p) { delete[] (p); (p) = NULL; } }
#define SAFE_RELEASE(p) { if (p) { (p)->Release(); (p) = NULL; } }
#define LOWER(c) (((c)>='A' && (c) <= 'Z') ? ((c)+('a'-'A')) : (c))
#define UPPER(c) (((c)>='a' && (c) <= 'z') ? ((c)+('A'-'a')) : (c))
#define str_cmp strcasecmp
#define STRNCPY(dst, src, len) do {strncpy(dst, src, len); dst[len] = '\0'; } while(0)
extern char * str_dup(const char * source); // <20>޸<EFBFBD><DEB8><EFBFBD> <20>Ҵ<EFBFBD> <20>ؼ<EFBFBD> source <20><><EFBFBD><EFBFBD> <20>Ѱ<EFBFBD> <20><><EFBFBD><EFBFBD>
extern void printdata(const unsigned char * data, int bytes); // data<74><61> hex<65><78> ascii<69><69> <20><><EFBFBD><EFBFBD> (<28><>Ŷ <20>м<EFBFBD> <20><20><><EFBFBD><EFBFBD>)
extern int filesize(FILE * fp); // <20><><EFBFBD><EFBFBD> ũ<><C5A9> <20><><EFBFBD><EFBFBD>
#define core_dump() core_dump_unix(__FILE__, __LINE__)
extern void core_dump_unix(const char *who, WORD line); // <20>ھ<20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
#define TOKEN(string) if (!str_cmp(token_string, string))
// src = <20><>ū : <20><>
extern void parse_token(char * src, char * token, char * value);
extern void trim_and_lower(const char * src, char * dest, size_t dest_size);
// <20><><EFBFBD>ڿ<EFBFBD><DABF><EFBFBD> <20>ҹ<EFBFBD><D2B9>ڷ<EFBFBD>
extern void lower_string(const char * src, char * dest, size_t dest_len);
// arg1<67><31> arg2<67><32> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ°<CFB4>? (<28><><EFBFBD>ҹ<EFBFBD><D2B9><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>)
extern int is_abbrev(char *arg1, char *arg2);
// a<><61> b<><62> <20>ð<EFBFBD><C3B0><EFBFBD> <20>󸶳<EFBFBD> <20><><EFBFBD>̳<EFBFBD><CCB3><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
extern struct timeval * timediff(const struct timeval *a, const struct timeval *b);
// a<><61> <20>ð<EFBFBD><C3B0><EFBFBD> b<><62> <20>ð<EFBFBD><C3B0><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
extern struct timeval * timeadd(struct timeval *a, struct timeval *b);
// <20><><EFBFBD><EFBFBD> <20>ð<EFBFBD> curr_tm<74><6D><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> days<79><73> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
extern struct tm * tm_calc(const struct tm *curr_tm, int days);
extern int MAX(int a, int b); // <20><><EFBFBD>߿<EFBFBD> ū <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
extern int MIN(int a, int b); // <20><><EFBFBD>߿<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
extern int MINMAX(int min, int value, int max); // <20>ּ<EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20>Բ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ؼ<EFBFBD> <20><><EFBFBD><EFBFBD>
extern int number_ex(int from, int to, const char *file, int line); // from<6F><6D><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> to<74><6F><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD>
#define number(from, to) number_ex(from, to, __FILE__, __LINE__)
float fnumber(float from, float to);
extern void thecore_sleep(struct timeval * timeout); // timeout<75><74>ŭ <20><><EFBFBD>μ<EFBFBD><CEBC><EFBFBD> <20><><EFBFBD><EFBFBD>
extern DWORD thecore_random(); // <20><><EFBFBD><EFBFBD> <20>Լ<EFBFBD>
extern float get_float_time();
extern DWORD get_dword_time();
extern char * time_str(time_t ct);
#define CREATE(result, type, number) do { \
if (!((result) = (type *) calloc ((number), sizeof(type)))) { \
sys_err("calloc failed [%d] %s", errno, strerror(errno)); \
abort(); } } while(0)
#define RECREATE(result,type,number) do { \
if (!((result) = (type *) realloc ((result), sizeof(type) * (number)))) { \
sys_err("realloc failed [%d] %s", errno, strerror(errno)); \
abort(); } } while(0)
// Next <20><> Prev <20><> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20>߰<EFBFBD>
#define INSERT_TO_TW_LIST(item, head, prev, next) \
if (!(head)) \
{ \
head = item; \
(head)->prev = (head)->next = NULL; \
} \
else \
{ \
(head)->prev = item; \
(item)->next = head; \
(item)->prev = NULL; \
head = item; \
}
#define REMOVE_FROM_TW_LIST(item, head, prev, next) \
if ((item) == (head)) \
{ \
if (((head) = (item)->next)) \
(head)->prev = NULL; \
} \
else \
{ \
if ((item)->next) \
(item)->next->prev = (item)->prev; \
\
if ((item)->prev) \
(item)->prev->next = (item)->next; \
}
#define INSERT_TO_LIST(item, head, next) \
(item)->next = (head); \
(head) = (item); \
#define REMOVE_FROM_LIST(item, head, next) \
if ((item) == (head)) \
head = (item)->next; \
else \
{ \
temp = head; \
\
while (temp && (temp->next != (item))) \
temp = temp->next; \
\
if (temp) \
temp->next = (item)->next; \
} \
#ifndef MAKEFOURCC
#define MAKEFOURCC(ch0, ch1, ch2, ch3) \
((DWORD)(BYTE) (ch0 ) | ((DWORD)(BYTE) (ch1) << 8) | \
((DWORD)(BYTE) (ch2) << 16) | ((DWORD)(BYTE) (ch3) << 24))
#endif // defined(MAKEFOURCC)
#ifdef __cplusplus
}
#endif // __cplusplus
// _countof for gcc/g++
#if !defined(_countof)
#if !defined(__cplusplus)
#define _countof(_Array) (sizeof(_Array) / sizeof(_Array[0]))
#else
extern "C++"
{
template <typename _CountofType, size_t _SizeOfArray>
char (*__countof_helper(_CountofType (&_Array)[_SizeOfArray]))[_SizeOfArray];
#define _countof(_Array) sizeof(*__countof_helper(_Array))
}
#endif
#endif
#ifdef __WIN32__
extern void gettimeofday(struct timeval* t, struct timezone* dummy);
#endif
#endif // __INC_UTILS_H__

50
libthecore/include/xdirent.h Normal file
View File

@ -0,0 +1,50 @@
#ifndef DIRENT_INCLUDED
#define DIRENT_INCLUDED
/*
Declaration of POSIX directory browsing functions and types for Win32.
Author: Kevlin Henney (kevlin@acm.org, kevlin@curbralan.com)
History: Created March 1997. Updated June 2003.
Rights: See end of file.
*/
#ifdef __cplusplus
extern "C"
{
#endif
typedef struct DIR DIR;
struct dirent
{
char *d_name;
};
DIR *opendir(const char *);
int closedir(DIR *);
struct dirent *readdir(DIR *);
void rewinddir(DIR *);
/*
Copyright Kevlin Henney, 1997, 2003. All rights reserved.
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose is hereby granted without fee, provided
that this copyright and permissions notice appear in all copies and
derivatives.
This software is supplied "as is" without express or implied warranty.
But that said, if there are any problems please get in touch.
*/
#ifdef __cplusplus
}
#endif
#endif

23
libthecore/include/xgetopt.h Normal file
View File

@ -0,0 +1,23 @@
// XGetopt.h Version 1.2
//
// Author: Hans Dietrich
// hdietrich2@hotmail.com
//
// This software is released into the public domain.
// You are free to use it in any way you like.
//
// This software is provided "as is" with no expressed
// or implied warranty. I accept no liability for any
// damage or loss of business that this software may cause.
//
///////////////////////////////////////////////////////////////////////////////
#ifndef XGETOPT_H
#define XGETOPT_H
extern int optind, opterr, optreset;
extern TCHAR *optarg;
int getopt(int argc, TCHAR *argv[], TCHAR *optstring);
#endif //XGETOPT_H

82
libthecore/include/xmd5.h Normal file
View File

@ -0,0 +1,82 @@
#ifndef __FreeBSD__
/*
* luau (Lib Update/Auto-Update): Simple Update Library
* Copyright (C) 2003 David Eklund
*
* - This library is free software; you can redistribute it and/or -
* - modify it under the terms of the GNU Lesser General Public -
* - License as published by the Free Software Foundation; either -
* - version 2.1 of the License, or (at your option) any later version. -
* - -
* - This library is distributed in the hope that it will be useful, -
* - but WITHOUT ANY WARRANTY; without even the implied warranty of -
* - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -
* - Lesser General Public License for more details. -
* - -
* - You should have received a copy of the GNU Lesser General Public -
* - License along with this library; if not, write to the Free Software -
* - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -
*/
/*
* md5.h and md5.c are based off of md5hl.c, md5c.c, and md5.h from libmd, which in turn are
* based off the FreeBSD libmd library. Their respective copyright notices follow:
*/
/*
* This code implements the MD5 message-digest algorithm.
* The algorithm is due to Ron Rivest. This code was
* written by Colin Plumb in 1993, no copyright is claimed.
* This code is in the public domain; do with it what you wish.
*
* Equivalent code is available from RSA Data Security, Inc.
* This code has been tested against that, and is equivalent,
* except that you don't need to include two pages of legalese
* with every copy.
*/
/* ----------------------------------------------------------------------------
* "THE BEER-WARE LICENSE" (Revision 42):
* <phk@login.dkuug.dk> wrote this file. As long as you retain this notice you
* can do whatever you want with this stuff. If we meet some day, and you think
* this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
* ----------------------------------------------------------------------------
*
* $Id: md5.h,v 1.1.1.1 2004/04/02 05:11:38 deklund2 Exp $
*
*/
#ifndef MD5_H
#define MD5_H
#include <sys/types.h>
#define MD5_HASHBYTES 16
typedef struct MD5Context {
uint32_t buf[4];
uint32_t bits[2];
unsigned char in[64];
} MD5_CTX;
#ifdef __cplusplus
extern "C" {
#endif
void MD5Init(MD5_CTX *context);
void MD5Update(MD5_CTX *context, unsigned char const *buf, unsigned len);
void MD5Final(unsigned char digest[MD5_HASHBYTES], MD5_CTX *context);
void MD5Transform(uint32_t buf[4], uint32_t const in[16]);
char* MD5End(MD5_CTX *, char *);
char* lutil_md5_file(const char *filename, char *buf);
char* lutil_md5_data(const unsigned char *data, unsigned int len, char *buf);
#ifdef __cplusplus
}
#endif
#endif /* MD5_H */
#endif // #ifndef __FreeBSD__

326
libthecore/src/DES_table.h Normal file
View File

@ -0,0 +1,326 @@
static DWORD SP_boxes[8][64]=
{
/* 0 */
{
0x00820200, 0x00020000, 0x80800000, 0x80820200,
0x00800000, 0x80020200, 0x80020000, 0x80800000,
0x80020200, 0x00820200, 0x00820000, 0x80000200,
0x80800200, 0x00800000, 0x00000000, 0x80020000,
0x00020000, 0x80000000, 0x00800200, 0x00020200,
0x80820200, 0x00820000, 0x80000200, 0x00800200,
0x80000000, 0x00000200, 0x00020200, 0x80820000,
0x00000200, 0x80800200, 0x80820000, 0x00000000,
0x00000000, 0x80820200, 0x00800200, 0x80020000,
0x00820200, 0x00020000, 0x80000200, 0x00800200,
0x80820000, 0x00000200, 0x00020200, 0x80800000,
0x80020200, 0x80000000, 0x80800000, 0x00820000,
0x80820200, 0x00020200, 0x00820000, 0x80800200,
0x00800000, 0x80000200, 0x80020000, 0x00000000,
0x00020000, 0x00800000, 0x80800200, 0x00820200,
0x80000000, 0x80820000, 0x00000200, 0x80020200
},
/* 1 */
{
0x10042004, 0x00000000, 0x00042000, 0x10040000,
0x10000004, 0x00002004, 0x10002000, 0x00042000,
0x00002000, 0x10040004, 0x00000004, 0x10002000,
0x00040004, 0x10042000, 0x10040000, 0x00000004,
0x00040000, 0x10002004, 0x10040004, 0x00002000,
0x00042004, 0x10000000, 0x00000000, 0x00040004,
0x10002004, 0x00042004, 0x10042000, 0x10000004,
0x10000000, 0x00040000, 0x00002004, 0x10042004,
0x00040004, 0x10042000, 0x10002000, 0x00042004,
0x10042004, 0x00040004, 0x10000004, 0x00000000,
0x10000000, 0x00002004, 0x00040000, 0x10040004,
0x00002000, 0x10000000, 0x00042004, 0x10002004,
0x10042000, 0x00002000, 0x00000000, 0x10000004,
0x00000004, 0x10042004, 0x00042000, 0x10040000,
0x10040004, 0x00040000, 0x00002004, 0x10002000,
0x10002004, 0x00000004, 0x10040000, 0x00042000
},
/* 2 */
{
0x41000000, 0x01010040, 0x00000040, 0x41000040,
0x40010000, 0x01000000, 0x41000040, 0x00010040,
0x01000040, 0x00010000, 0x01010000, 0x40000000,
0x41010040, 0x40000040, 0x40000000, 0x41010000,
0x00000000, 0x40010000, 0x01010040, 0x00000040,
0x40000040, 0x41010040, 0x00010000, 0x41000000,
0x41010000, 0x01000040, 0x40010040, 0x01010000,
0x00010040, 0x00000000, 0x01000000, 0x40010040,
0x01010040, 0x00000040, 0x40000000, 0x00010000,
0x40000040, 0x40010000, 0x01010000, 0x41000040,
0x00000000, 0x01010040, 0x00010040, 0x41010000,
0x40010000, 0x01000000, 0x41010040, 0x40000000,
0x40010040, 0x41000000, 0x01000000, 0x41010040,
0x00010000, 0x01000040, 0x41000040, 0x00010040,
0x01000040, 0x00000000, 0x41010000, 0x40000040,
0x41000000, 0x40010040, 0x00000040, 0x01010000
},
/* 3 */
{
0x00100402, 0x04000400, 0x00000002, 0x04100402,
0x00000000, 0x04100000, 0x04000402, 0x00100002,
0x04100400, 0x04000002, 0x04000000, 0x00000402,
0x04000002, 0x00100402, 0x00100000, 0x04000000,
0x04100002, 0x00100400, 0x00000400, 0x00000002,
0x00100400, 0x04000402, 0x04100000, 0x00000400,
0x00000402, 0x00000000, 0x00100002, 0x04100400,
0x04000400, 0x04100002, 0x04100402, 0x00100000,
0x04100002, 0x00000402, 0x00100000, 0x04000002,
0x00100400, 0x04000400, 0x00000002, 0x04100000,
0x04000402, 0x00000000, 0x00000400, 0x00100002,
0x00000000, 0x04100002, 0x04100400, 0x00000400,
0x04000000, 0x04100402, 0x00100402, 0x00100000,
0x04100402, 0x00000002, 0x04000400, 0x00100402,
0x00100002, 0x00100400, 0x04100000, 0x04000402,
0x00000402, 0x04000000, 0x04000002, 0x04100400
},
/* 4 */
{
0x02000000, 0x00004000, 0x00000100, 0x02004108,
0x02004008, 0x02000100, 0x00004108, 0x02004000,
0x00004000, 0x00000008, 0x02000008, 0x00004100,
0x02000108, 0x02004008, 0x02004100, 0x00000000,
0x00004100, 0x02000000, 0x00004008, 0x00000108,
0x02000100, 0x00004108, 0x00000000, 0x02000008,
0x00000008, 0x02000108, 0x02004108, 0x00004008,
0x02004000, 0x00000100, 0x00000108, 0x02004100,
0x02004100, 0x02000108, 0x00004008, 0x02004000,
0x00004000, 0x00000008, 0x02000008, 0x02000100,
0x02000000, 0x00004100, 0x02004108, 0x00000000,
0x00004108, 0x02000000, 0x00000100, 0x00004008,
0x02000108, 0x00000100, 0x00000000, 0x02004108,
0x02004008, 0x02004100, 0x00000108, 0x00004000,
0x00004100, 0x02004008, 0x02000100, 0x00000108,
0x00000008, 0x00004108, 0x02004000, 0x02000008
},
/* 5 */
{
0x20000010, 0x00080010, 0x00000000, 0x20080800,
0x00080010, 0x00000800, 0x20000810, 0x00080000,
0x00000810, 0x20080810, 0x00080800, 0x20000000,
0x20000800, 0x20000010, 0x20080000, 0x00080810,
0x00080000, 0x20000810, 0x20080010, 0x00000000,
0x00000800, 0x00000010, 0x20080800, 0x20080010,
0x20080810, 0x20080000, 0x20000000, 0x00000810,
0x00000010, 0x00080800, 0x00080810, 0x20000800,
0x00000810, 0x20000000, 0x20000800, 0x00080810,
0x20080800, 0x00080010, 0x00000000, 0x20000800,
0x20000000, 0x00000800, 0x20080010, 0x00080000,
0x00080010, 0x20080810, 0x00080800, 0x00000010,
0x20080810, 0x00080800, 0x00080000, 0x20000810,
0x20000010, 0x20080000, 0x00080810, 0x00000000,
0x00000800, 0x20000010, 0x20000810, 0x20080800,
0x20080000, 0x00000810, 0x00000010, 0x20080010
},
/* 6 */
{
0x00001000, 0x00000080, 0x00400080, 0x00400001,
0x00401081, 0x00001001, 0x00001080, 0x00000000,
0x00400000, 0x00400081, 0x00000081, 0x00401000,
0x00000001, 0x00401080, 0x00401000, 0x00000081,
0x00400081, 0x00001000, 0x00001001, 0x00401081,
0x00000000, 0x00400080, 0x00400001, 0x00001080,
0x00401001, 0x00001081, 0x00401080, 0x00000001,
0x00001081, 0x00401001, 0x00000080, 0x00400000,
0x00001081, 0x00401000, 0x00401001, 0x00000081,
0x00001000, 0x00000080, 0x00400000, 0x00401001,
0x00400081, 0x00001081, 0x00001080, 0x00000000,
0x00000080, 0x00400001, 0x00000001, 0x00400080,
0x00000000, 0x00400081, 0x00400080, 0x00001080,
0x00000081, 0x00001000, 0x00401081, 0x00400000,
0x00401080, 0x00000001, 0x00001001, 0x00401081,
0x00400001, 0x00401080, 0x00401000, 0x00001001
},
/* 7 */
{
0x08200020, 0x08208000, 0x00008020, 0x00000000,
0x08008000, 0x00200020, 0x08200000, 0x08208020,
0x00000020, 0x08000000, 0x00208000, 0x00008020,
0x00208020, 0x08008020, 0x08000020, 0x08200000,
0x00008000, 0x00208020, 0x00200020, 0x08008000,
0x08208020, 0x08000020, 0x00000000, 0x00208000,
0x08000000, 0x00200000, 0x08008020, 0x08200020,
0x00200000, 0x00008000, 0x08208000, 0x00000020,
0x00200000, 0x00008000, 0x08000020, 0x08208020,
0x00008020, 0x08000000, 0x00000000, 0x00208000,
0x08200020, 0x08008020, 0x08008000, 0x00200020,
0x08208000, 0x00000020, 0x00200020, 0x08008000,
0x08208020, 0x00200000, 0x08200000, 0x08000020,
0x00208000, 0x00008020, 0x08008020, 0x08200000,
0x00000020, 0x08208000, 0x00208020, 0x00000000,
0x08000000, 0x08200020, 0x00008000, 0x00208020
}
};
static DWORD KeyPerm[8][64] =
{
/* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
{
0x00000000,0x00000010,0x20000000,0x20000010,
0x00010000,0x00010010,0x20010000,0x20010010,
0x00000800,0x00000810,0x20000800,0x20000810,
0x00010800,0x00010810,0x20010800,0x20010810,
0x00000020,0x00000030,0x20000020,0x20000030,
0x00010020,0x00010030,0x20010020,0x20010030,
0x00000820,0x00000830,0x20000820,0x20000830,
0x00010820,0x00010830,0x20010820,0x20010830,
0x00080000,0x00080010,0x20080000,0x20080010,
0x00090000,0x00090010,0x20090000,0x20090010,
0x00080800,0x00080810,0x20080800,0x20080810,
0x00090800,0x00090810,0x20090800,0x20090810,
0x00080020,0x00080030,0x20080020,0x20080030,
0x00090020,0x00090030,0x20090020,0x20090030,
0x00080820,0x00080830,0x20080820,0x20080830,
0x00090820,0x00090830,0x20090820,0x20090830
},
/* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
{
0x00000000,0x02000000,0x00002000,0x02002000,
0x00200000,0x02200000,0x00202000,0x02202000,
0x00000004,0x02000004,0x00002004,0x02002004,
0x00200004,0x02200004,0x00202004,0x02202004,
0x00000400,0x02000400,0x00002400,0x02002400,
0x00200400,0x02200400,0x00202400,0x02202400,
0x00000404,0x02000404,0x00002404,0x02002404,
0x00200404,0x02200404,0x00202404,0x02202404,
0x10000000,0x12000000,0x10002000,0x12002000,
0x10200000,0x12200000,0x10202000,0x12202000,
0x10000004,0x12000004,0x10002004,0x12002004,
0x10200004,0x12200004,0x10202004,0x12202004,
0x10000400,0x12000400,0x10002400,0x12002400,
0x10200400,0x12200400,0x10202400,0x12202400,
0x10000404,0x12000404,0x10002404,0x12002404,
0x10200404,0x12200404,0x10202404,0x12202404
},
/* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
{
0x00000000,0x00000001,0x00040000,0x00040001,
0x01000000,0x01000001,0x01040000,0x01040001,
0x00000002,0x00000003,0x00040002,0x00040003,
0x01000002,0x01000003,0x01040002,0x01040003,
0x00000200,0x00000201,0x00040200,0x00040201,
0x01000200,0x01000201,0x01040200,0x01040201,
0x00000202,0x00000203,0x00040202,0x00040203,
0x01000202,0x01000203,0x01040202,0x01040203,
0x08000000,0x08000001,0x08040000,0x08040001,
0x09000000,0x09000001,0x09040000,0x09040001,
0x08000002,0x08000003,0x08040002,0x08040003,
0x09000002,0x09000003,0x09040002,0x09040003,
0x08000200,0x08000201,0x08040200,0x08040201,
0x09000200,0x09000201,0x09040200,0x09040201,
0x08000202,0x08000203,0x08040202,0x08040203,
0x09000202,0x09000203,0x09040202,0x09040203
},
/* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
{
0x00000000,0x00100000,0x00000100,0x00100100,
0x00000008,0x00100008,0x00000108,0x00100108,
0x00001000,0x00101000,0x00001100,0x00101100,
0x00001008,0x00101008,0x00001108,0x00101108,
0x04000000,0x04100000,0x04000100,0x04100100,
0x04000008,0x04100008,0x04000108,0x04100108,
0x04001000,0x04101000,0x04001100,0x04101100,
0x04001008,0x04101008,0x04001108,0x04101108,
0x00020000,0x00120000,0x00020100,0x00120100,
0x00020008,0x00120008,0x00020108,0x00120108,
0x00021000,0x00121000,0x00021100,0x00121100,
0x00021008,0x00121008,0x00021108,0x00121108,
0x04020000,0x04120000,0x04020100,0x04120100,
0x04020008,0x04120008,0x04020108,0x04120108,
0x04021000,0x04121000,0x04021100,0x04121100,
0x04021008,0x04121008,0x04021108,0x04121108
},
/* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
{
0x00000000,0x10000000,0x00010000,0x10010000,
0x00000004,0x10000004,0x00010004,0x10010004,
0x20000000,0x30000000,0x20010000,0x30010000,
0x20000004,0x30000004,0x20010004,0x30010004,
0x00100000,0x10100000,0x00110000,0x10110000,
0x00100004,0x10100004,0x00110004,0x10110004,
0x20100000,0x30100000,0x20110000,0x30110000,
0x20100004,0x30100004,0x20110004,0x30110004,
0x00001000,0x10001000,0x00011000,0x10011000,
0x00001004,0x10001004,0x00011004,0x10011004,
0x20001000,0x30001000,0x20011000,0x30011000,
0x20001004,0x30001004,0x20011004,0x30011004,
0x00101000,0x10101000,0x00111000,0x10111000,
0x00101004,0x10101004,0x00111004,0x10111004,
0x20101000,0x30101000,0x20111000,0x30111000,
0x20101004,0x30101004,0x20111004,0x30111004
},
/* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
{
0x00000000,0x08000000,0x00000008,0x08000008,
0x00000400,0x08000400,0x00000408,0x08000408,
0x00020000,0x08020000,0x00020008,0x08020008,
0x00020400,0x08020400,0x00020408,0x08020408,
0x00000001,0x08000001,0x00000009,0x08000009,
0x00000401,0x08000401,0x00000409,0x08000409,
0x00020001,0x08020001,0x00020009,0x08020009,
0x00020401,0x08020401,0x00020409,0x08020409,
0x02000000,0x0A000000,0x02000008,0x0A000008,
0x02000400,0x0A000400,0x02000408,0x0A000408,
0x02020000,0x0A020000,0x02020008,0x0A020008,
0x02020400,0x0A020400,0x02020408,0x0A020408,
0x02000001,0x0A000001,0x02000009,0x0A000009,
0x02000401,0x0A000401,0x02000409,0x0A000409,
0x02020001,0x0A020001,0x02020009,0x0A020009,
0x02020401,0x0A020401,0x02020409,0x0A020409
},
/* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
{
0x00000000,0x00000100,0x00080000,0x00080100,
0x01000000,0x01000100,0x01080000,0x01080100,
0x00000010,0x00000110,0x00080010,0x00080110,
0x01000010,0x01000110,0x01080010,0x01080110,
0x00200000,0x00200100,0x00280000,0x00280100,
0x01200000,0x01200100,0x01280000,0x01280100,
0x00200010,0x00200110,0x00280010,0x00280110,
0x01200010,0x01200110,0x01280010,0x01280110,
0x00000200,0x00000300,0x00080200,0x00080300,
0x01000200,0x01000300,0x01080200,0x01080300,
0x00000210,0x00000310,0x00080210,0x00080310,
0x01000210,0x01000310,0x01080210,0x01080310,
0x00200200,0x00200300,0x00280200,0x00280300,
0x01200200,0x01200300,0x01280200,0x01280300,
0x00200210,0x00200310,0x00280210,0x00280310,
0x01200210,0x01200310,0x01280210,0x01280310
},
/* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
{
0x00000000,0x04000000,0x00040000,0x04040000,
0x00000002,0x04000002,0x00040002,0x04040002,
0x00002000,0x04002000,0x00042000,0x04042000,
0x00002002,0x04002002,0x00042002,0x04042002,
0x00000020,0x04000020,0x00040020,0x04040020,
0x00000022,0x04000022,0x00040022,0x04040022,
0x00002020,0x04002020,0x00042020,0x04042020,
0x00002022,0x04002022,0x00042022,0x04042022,
0x00000800,0x04000800,0x00040800,0x04040800,
0x00000802,0x04000802,0x00040802,0x04040802,
0x00002800,0x04002800,0x00042800,0x04042800,
0x00002802,0x04002802,0x00042802,0x04042802,
0x00000820,0x04000820,0x00040820,0x04040820,
0x00000822,0x04000822,0x00040822,0x04040822,
0x00002820,0x04002820,0x00042820,0x04042820,
0x00002822,0x04002822,0x00042822,0x04042822
}
};

294
libthecore/src/buffer.c Normal file
View File

@ -0,0 +1,294 @@
/*
* Filename: buffer.c
* Description: Buffer ó<><C3B3> <20><><EFBFBD><EFBFBD>
*
* Author: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (aka. <20><><EFBFBD><EFBFBD>, Cronan)
*/
#define __LIBTHECORE__
#include "stdafx.h"
static LPBUFFER normalized_buffer_pool[32] = { NULL, };
#define DEFAULT_POOL_SIZE 8192
// internal function forward
void buffer_realloc(LPBUFFER& buffer, int length);
static int buffer_get_pool_index(int size) {
int i;
for (i = 0; i < 32; ++i) {
if ((1 << i) >= size) {
return i;
}
}
return -1; // too big... not pooled
}
static int buffer_get_exac_pool_index(int size) {
int i;
for (i = 0; i < 32; ++i) {
if ((1 << i) == size) {
return i;
}
}
return -1; // too big... not pooled
}
// <20><><EFBFBD><EFBFBD> buffer pool <20><><EFBFBD><EFBFBD>.
static void buffer_pool_free ()
{
for (int i = 31; i >= 0; i--)
{
if (normalized_buffer_pool[i] != NULL)
{
LPBUFFER next;
for (LPBUFFER p = normalized_buffer_pool[i]; p != NULL; p = next)
{
next = p->next;
free(p->mem_data);
free(p);
}
normalized_buffer_pool[i] = NULL;
}
}
}
// n<><6E><EFBFBD><EFBFBD> ū buffer pool <20>ϳ<EFBFBD><CFB3><EFBFBD> <20><><EFBFBD><EFBFBD>.
static bool buffer_larger_pool_free (int n)
{
for (int i = 31; i > n; i--)
{
if (normalized_buffer_pool[i] != NULL)
{
LPBUFFER buffer = normalized_buffer_pool[i];
LPBUFFER next = buffer->next;
free(buffer->mem_data);
free(buffer);
normalized_buffer_pool[i] = next;
return true;
}
}
return false;
}
bool safe_create(char** pdata, int number)
{
if (!((*pdata) = (char *) calloc (number, sizeof(char))))
{
sys_err("calloc failed [%d] %s", errno, strerror(errno));
return false;
}
else
{
return true;
}
}
LPBUFFER buffer_new(int size)
{
if (size < 0) {
return NULL;
}
LPBUFFER buffer = NULL;
int pool_index = buffer_get_pool_index(size);
if (pool_index >= 0) {
BUFFER** buffer_pool = normalized_buffer_pool + pool_index;
size = 1 << pool_index;
if (*buffer_pool) {
buffer = *buffer_pool;
*buffer_pool = buffer->next;
}
}
if (buffer == NULL)
{
CREATE(buffer, BUFFER, 1);
buffer->mem_size = size;
// buffer_new<65><77><EFBFBD><EFBFBD> calloc failed<65><64> <20><><EFBFBD><EFBFBD> <20>߻<EFBFBD><DFBB>Ͽ<EFBFBD>(<28><>Ű<EFBFBD><C5B0> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ӽſ<D3BD><C5BF><EFBFBD> <20>ַ<EFBFBD> <20>߻<EFBFBD>),
// calloc<6F><63> <20><><EFBFBD><EFBFBD><EFBFBD>ϸ<EFBFBD>, buffer pool<6F><6C> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٽ<EFBFBD> <20>õ<EFBFBD><C3B5>Ѵ<EFBFBD>.
if (!safe_create(&buffer->mem_data, size))
{
// <20>ʿ<EFBFBD><CABF><EFBFBD> buffer<65><72><EFBFBD><EFBFBD> ū buffer pool<6F><6C><EFBFBD><EFBFBD> <20>ϳ<EFBFBD><CFB3><EFBFBD> <20><><EFBFBD><EFBFBD>.
if (!buffer_larger_pool_free(pool_index))
// <20><><EFBFBD><EFBFBD><EFBFBD>ϸ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD> pool<6F><6C> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
buffer_pool_free();
CREATE(buffer->mem_data, char, size);
sys_err ("buffer pool free success.");
}
}
assert(buffer != NULL);
assert(buffer->mem_size == size);
assert(buffer->mem_data != NULL);
buffer_reset(buffer);
return buffer;
}
void buffer_delete(LPBUFFER buffer)
{
if (buffer == NULL) {
return;
}
buffer_reset(buffer);
int size = buffer->mem_size;
int pool_index = buffer_get_exac_pool_index(size);
if (pool_index >= 0) {
BUFFER** buffer_pool = normalized_buffer_pool + pool_index;
buffer->next = *buffer_pool;
*buffer_pool = buffer;
}
else {
free(buffer->mem_data);
free(buffer);
}
}
DWORD buffer_size(LPBUFFER buffer)
{
return (buffer->length);
}
void buffer_reset(LPBUFFER buffer)
{
buffer->read_point = buffer->mem_data;
buffer->write_point = buffer->mem_data;
buffer->write_point_pos = 0;
buffer->length = 0;
buffer->next = NULL;
buffer->flag = 0;
}
void buffer_write(LPBUFFER& buffer, const void *src, int length)
{
if (buffer->write_point_pos + length >= buffer->mem_size)
buffer_realloc(buffer, buffer->mem_size + length + MIN(10240, length));
thecore_memcpy(buffer->write_point, src, length);
buffer_write_proceed(buffer, length);
}
void buffer_read(LPBUFFER buffer, void * buf, int bytes)
{
thecore_memcpy(buf, buffer->read_point, bytes);
buffer_read_proceed(buffer, bytes);
}
BYTE buffer_byte(LPBUFFER buffer)
{
BYTE val = *(BYTE *) buffer->read_point;
buffer_read_proceed(buffer, sizeof(BYTE));
return val;
}
WORD buffer_word(LPBUFFER buffer)
{
WORD val = *(WORD *) buffer->read_point;
buffer_read_proceed(buffer, sizeof(WORD));
return val;
}
DWORD buffer_dword(LPBUFFER buffer)
{
DWORD val = *(DWORD *) buffer->read_point;
buffer_read_proceed(buffer, sizeof(DWORD));
return val;
}
const void * buffer_read_peek(LPBUFFER buffer)
{
return (const void *) buffer->read_point;
}
void buffer_read_proceed(LPBUFFER buffer, int length)
{
if (length == 0)
return;
if (length < 0)
sys_err("buffer_proceed: length argument lower than zero (length: %d)", length);
else if (length > buffer->length)
{
sys_err("buffer_proceed: length argument bigger than buffer (length: %d, buffer: %d)", length, buffer->length);
length = buffer->length;
}
// ó<><C3B3><EFBFBD><EFBFBD> <20><><EFBFBD>̰<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̺<EFBFBD><CCBA><EFBFBD> <20>۴ٸ<DBB4>, <20><><EFBFBD>۸<EFBFBD> <20><><EFBFBD>ܵξ<DCB5><CEBE><EFBFBD> <20>Ѵ<EFBFBD>.
if (length < buffer->length)
{
// write_point <20><> pos <20><> <20>״<EFBFBD><D7B4><EFBFBD> <20>ΰ<EFBFBD> read_point <20><> <20><><EFBFBD><EFBFBD> <20><>Ų<EFBFBD><C5B2>.
if (buffer->read_point + length - buffer->mem_data > buffer->mem_size)
{
sys_err("buffer_read_proceed: buffer overflow! length %d read_point %d", length, buffer->read_point - buffer->mem_data);
abort();
}
buffer->read_point += length;
buffer->length -= length;
}
else
{
buffer_reset(buffer);
}
}
void * buffer_write_peek(LPBUFFER buffer)
{
return (buffer->write_point);
}
void buffer_write_proceed(LPBUFFER buffer, int length)
{
buffer->length += length;
buffer->write_point += length;
buffer->write_point_pos += length;
}
int buffer_has_space(LPBUFFER buffer)
{
return (buffer->mem_size - buffer->write_point_pos);
}
void buffer_adjust_size(LPBUFFER& buffer, int add_size)
{
if (buffer->mem_size >= buffer->write_point_pos + add_size)
return;
sys_log(0, "buffer_adjust %d current %d/%d", add_size, buffer->length, buffer->mem_size);
buffer_realloc(buffer, buffer->mem_size + add_size);
}
void buffer_realloc(LPBUFFER& buffer, int length)
{
int i, read_point_pos;
LPBUFFER temp;
assert(length >= 0 && "buffer_realloc: length is lower than zero");
if (buffer->mem_size >= length)
return;
// i <20><> <20><><EFBFBD><EFBFBD> <20>Ҵ<EFBFBD><D2B4><EFBFBD> ũ<><C5A9><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ũ<EFBFBD><C5A9><EFBFBD><EFBFBD> <20><>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
// <20>޸<EFBFBD><DEB8><EFBFBD><EFBFBD><EFBFBD> ũ<>⸦ <20><><EFBFBD>Ѵ<EFBFBD>.
i = length - buffer->mem_size;
if (i <= 0)
return;
temp = buffer_new (length);
sys_log(0, "reallocating buffer to %d, current %d", temp->mem_size, buffer->mem_size);
thecore_memcpy(temp->mem_data, buffer->mem_data, buffer->mem_size);
read_point_pos = buffer->read_point - buffer->mem_data;
// write_point <20><> read_point <20><> <20><> <20><><EFBFBD><EFBFBD> <20><>Ų<EFBFBD><C5B2>.
temp->write_point = temp->mem_data + buffer->write_point_pos;
temp->write_point_pos = buffer->write_point_pos;
temp->read_point = temp->mem_data + read_point_pos;
temp->flag = buffer->flag;
temp->next = NULL;
temp->length = buffer->length;
buffer_delete(buffer);
buffer = temp;
}

281
libthecore/src/des.c Normal file
View File

@ -0,0 +1,281 @@
#include "stdafx.h"
#include "DES_table.h"
#define DES_ECB_ENCRYPT 0
#define DES_ECB_DECRYPT 1
// DES ECB encryption code
extern DWORD SP_boxes[8][64];
//extern DWORD KeyPerm[8][64];
/*
* Macroses to transform array of 4 bytes to 32-bit dwords
* (and reverse) without depending on the Little-Endian or
* Big-Endian processor's architecture
*/
#define BYTES_TO_DWORD(b,d) (d = ((DWORD)(*((b)++))), \
d |= ((DWORD)(*((b)++)))<< 8, \
d |= ((DWORD)(*((b)++)))<<16, \
d |= ((DWORD)(*((b)++)))<<24)
#define DWORD_TO_4BYTES(d,b) (*((b)++)=(BYTE)(((d) )&0xff), \
*((b)++)=(BYTE)(((d)>> 8)&0xff), \
*((b)++)=(BYTE)(((d)>>16)&0xff), \
*((b)++)=(BYTE)(((d)>>24)&0xff))
/*
* First of all, take into accounts the bytes and bites ordering
* used in DES:
*
* DES: 1 2 3 4 5 6 7 8 .... 57 58 59 60 61 62 63 64
* INTEL: 63 62 61 60 59 58 57 56 .... 7 6 5 4 3 2 1 0
*
* According to the DES, every 8-th bits is not used:
* for DES the bites 8, 16, 32, ..., 64 are excluded,
* for INTEL: 56, 48, 40, ..., 0 are excluded
*
* According to the above rool of numbering, the tables
* used in DES (for Initial Permutation, Final Permutation,
* Key Permutation, Compression Permutation, Expansion
* Permutation and P-Box permutation) have to be re-written.
*
*/
/*
Some main ideas used to optimize DES software
implementation:
a). Do not make an Expansion Permutation of 32-bit to
48 bit (32-bit of data - right half of 64-bit of data),
but make a correspondent preparation of the Key. So,
the step of Expansion Permutation and XORing 48 bit of
Expanded data and 48 bit of Compressed key will be
replaced by 2 XOR operations: 32 bit of data XOR first
32 bit part of prepeared key, then, the same 32 bit of
data XOR second 32-bit part of prepeared key
b). Combine S-Box Substitution and P-Box Permutation
operations.
c). For the best performance 56-bit encryption key
have to be extendended to 128-byte array, i.e. for each
of 16 rounds of DES we prepare a unique pair of two
32-bit (4-bytes) words (see 'a)' above).
d). We can use XOR, SHIFT, AND operations to swap
bits between words. For example, we have:
word A word B
0 1 2 3 4 5 6 7
We want to get:
word A word B
0 4 2 6 1 5 3 7
First, shift word A to get bites 1, 3 on the "right place"
word TMP = (word A) >> 1 = 1 2 3 -
TMP = TMP ^ B = 1^4 2^5 3^6 7
we don't want to change bits 5 and 7 in the B word, so
TMP = TMP & MASK = TMP & 1010 = 1^4 - 3^6 -
now we can easy get the word B:
B = B ^ TMP = (4 5 6 7) ^ (1^4 - 3^6 -) = 1 5 3 7
if we shift our "masking" TMP word reverse - we get
a mask for A word:
TMP = TMP << 1 = - 1^4 - 3^6
now we can easy get the word A:
A = A ^ TMP = (0 1 2 3) ^ (- 1^4 - 3^6) = 0 4 2 6
The example above may be used to swap not only single
bits, but also bit sequencies. In this case you should
use shift on the value, equal to the number of bits
in pattern.
As you see, all this opearations may be written like:
TMP = ((A >> size) ^ B) & mask;
B ^ = TMP;
A ^= TMP << size;
*/
#define PERMUTATION(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
(b)^=(t),\
(a)^=((t)<<(n)))
#define HPERMUTATION(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\
(a)=(a)^(t)^(t>>(16-(n))))
#define D_ENCRYPT(Left, Right, Ks, Num, TmpA, TmpB) \
TmpA = (Right ^ Ks[Num ]); \
TmpB = (Right ^ Ks[Num+1]); \
TmpB = ((TmpB >> 4) + (TmpB << 28)); \
Left ^= SP_boxes[1][(TmpB )&0x3f]| \
SP_boxes[3][(TmpB>> 8)&0x3f]| \
SP_boxes[5][(TmpB>>16)&0x3f]| \
SP_boxes[7][(TmpB>>24)&0x3f]| \
SP_boxes[0][(TmpA )&0x3f]| \
SP_boxes[2][(TmpA>> 8)&0x3f]| \
SP_boxes[4][(TmpA>>16)&0x3f]| \
SP_boxes[6][(TmpA>>24)&0x3f];
void DES_ECB_mode(BYTE * Input, /* 8 bytes of input data */
BYTE * Output, /* 8 bytes of output data */
const DWORD * KeySchedule, /* [16][2] array of DWORDs */
BYTE Operation) /* DES_ECB_ENCRYPT or DES_ECB_DECRYPT */
{
static BYTE * bInp, * bOut;
static DWORD dwLeft, dwRigh, dwTmp, dwTmp1;
bInp = Input;
bOut = Output;
BYTES_TO_DWORD(bInp, dwLeft);
BYTES_TO_DWORD(bInp, dwRigh);
/* Initial Permutation */
PERMUTATION(dwRigh, dwLeft, dwTmp, 4, 0x0f0f0f0f);
PERMUTATION(dwLeft, dwRigh, dwTmp,16, 0x0000ffff);
PERMUTATION(dwRigh, dwLeft, dwTmp, 2, 0x33333333);
PERMUTATION(dwLeft, dwRigh, dwTmp, 8, 0x00ff00ff);
PERMUTATION(dwRigh, dwLeft, dwTmp, 1, 0x55555555);
/* dwRigh and dwLeft has reversed bit orders - itwill be taken
into account in the next step */
/* The initial rotate is done outside the loop. This required the
* SP_boxes values to be rotated 1 bit to the right.
*/
dwTmp = (dwRigh<<1) | (dwRigh>>31);
dwRigh = (dwLeft<<1) | (dwLeft>>31);
dwLeft = dwTmp;
/* clear the top bits on machines with 8byte longs */
dwLeft &= 0xffffffff;
dwRigh &= 0xffffffff;
if (Operation == DES_ECB_ENCRYPT)
{ /* Key order */
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 0, dwTmp, dwTmp1); /* 1 */
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 2, dwTmp, dwTmp1); /* 2 */
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 4, dwTmp, dwTmp1); /* 3 */
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 6, dwTmp, dwTmp1); /* 4 */
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 8, dwTmp, dwTmp1); /* 5 */
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 10, dwTmp, dwTmp1); /* 6 */
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 12, dwTmp, dwTmp1); /* 7 */
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 14, dwTmp, dwTmp1); /* 8 */
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 16, dwTmp, dwTmp1); /* 9 */
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 18, dwTmp, dwTmp1); /* 10 */
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 20, dwTmp, dwTmp1); /* 11 */
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 22, dwTmp, dwTmp1); /* 12 */
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 24, dwTmp, dwTmp1); /* 13 */
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 26, dwTmp, dwTmp1); /* 14 */
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 28, dwTmp, dwTmp1); /* 15 */
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 30, dwTmp, dwTmp1); /* 16 */
}
else
{
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 30, dwTmp, dwTmp1); /* 16 */
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 28, dwTmp, dwTmp1); /* 15 */
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 26, dwTmp, dwTmp1); /* 14 */
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 24, dwTmp, dwTmp1); /* 13 */
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 22, dwTmp, dwTmp1); /* 12 */
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 20, dwTmp, dwTmp1); /* 11 */
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 18, dwTmp, dwTmp1); /* 10 */
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 16, dwTmp, dwTmp1); /* 9 */
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 14, dwTmp, dwTmp1); /* 8 */
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 12, dwTmp, dwTmp1); /* 7 */
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 10, dwTmp, dwTmp1); /* 6 */
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 8, dwTmp, dwTmp1); /* 5 */
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 6, dwTmp, dwTmp1); /* 4 */
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 4, dwTmp, dwTmp1); /* 3 */
D_ENCRYPT(dwLeft, dwRigh, KeySchedule, 2, dwTmp, dwTmp1); /* 2 */
D_ENCRYPT(dwRigh, dwLeft, KeySchedule, 0, dwTmp, dwTmp1); /* 1 */
}
dwLeft = (dwLeft>>1) | (dwLeft<<31);
dwRigh = (dwRigh>>1) | (dwRigh<<31);
/* clear the top bits on machines with 8byte longs */
dwLeft &= 0xffffffff;
dwRigh &= 0xffffffff;
/*
* Do we need to swap dwLeft and dwRigh?
* We have not to do the swap
* (We remember they are reversed)
* So - all we have to do is to make a correspondent Final Permutation
*/
PERMUTATION(dwRigh, dwLeft, dwTmp, 1,0x55555555);
PERMUTATION(dwLeft, dwRigh, dwTmp, 8,0x00ff00ff);
PERMUTATION(dwRigh, dwLeft, dwTmp, 2,0x33333333);
PERMUTATION(dwLeft, dwRigh, dwTmp,16,0x0000ffff);
PERMUTATION(dwRigh, dwLeft, dwTmp, 4,0x0f0f0f0f);
/* Place our two 32-bits results into 8 bytes of output data */
DWORD_TO_4BYTES(dwLeft, bOut);
DWORD_TO_4BYTES(dwRigh, bOut);
}
//************ DES CBC mode encryption **************
int DES_Encrypt(DWORD *DstBuffer, const DWORD * SrcBuffer, const DWORD *KeyAddress, DWORD Length, DWORD *IVector)
{
DWORD i;
DWORD buffer[2];
buffer[0] = IVector[0];
buffer[1] = IVector[1];
for (i = 0; i < (Length >> 2); i = i+2)
{
// do EBC encryption of (Initial_Vector XOR Data)
buffer[0] ^= SrcBuffer[i];
buffer[1] ^= SrcBuffer[i+1];
DES_ECB_mode((BYTE *) buffer, (BYTE *) buffer, KeyAddress, DES_ECB_ENCRYPT);
DstBuffer[i] = buffer[0];
DstBuffer[i+1] = buffer[1];
}
return Length;
}
//************ DES CBC mode decryption **************
int DES_Decrypt(DWORD *DstBuffer, const DWORD * SrcBuffer, const DWORD *KeyAddress, DWORD Length, DWORD *IVector)
{
DWORD i;
DWORD buffer[2], ivectorL, ivectorR, oldSrcL, oldSrcR;
ivectorL = IVector[0];
ivectorR = IVector[1];
for (i = 0; i < (Length >> 2); i = i + 2)
{
buffer[0] = oldSrcL = SrcBuffer[i];
buffer[1] = oldSrcR = SrcBuffer[i+1];
// Encrypted Data -> new IV,
// then do EBC decryption of Encrypted Data,
// then XOR decrypted data with old IV
DES_ECB_mode((BYTE *)buffer, (BYTE *)buffer, KeyAddress, DES_ECB_DECRYPT);
DstBuffer[i] = buffer[0] ^ ivectorL;
DstBuffer[i+1] = buffer[1] ^ ivectorR;
ivectorL = oldSrcL;
ivectorR = oldSrcR;
}
return Length;
}

461
libthecore/src/fdwatch.c Normal file
View File

@ -0,0 +1,461 @@
#define __LIBTHECORE__
#include "stdafx.h"
#ifndef __USE_SELECT__
LPFDWATCH fdwatch_new(int nfiles)
{
LPFDWATCH fdw;
int kq;
kq = kqueue();
if (kq == -1)
{
sys_err("%s", strerror(errno));
return NULL;
}
CREATE(fdw, FDWATCH, 1);
fdw->kq = kq;
fdw->nfiles = nfiles;
fdw->nkqevents = 0;
CREATE(fdw->kqevents, KEVENT, nfiles * 2);
CREATE(fdw->kqrevents, KEVENT, nfiles * 2);
CREATE(fdw->fd_event_idx, int, nfiles);
CREATE(fdw->fd_rw, int, nfiles);
CREATE(fdw->fd_data, void*, nfiles);
return (fdw);
}
void fdwatch_delete(LPFDWATCH fdw)
{
free(fdw->fd_data);
free(fdw->fd_rw);
free(fdw->kqevents);
free(fdw->kqrevents);
free(fdw->fd_event_idx);
free(fdw);
}
int fdwatch(LPFDWATCH fdw, struct timeval *timeout)
{
int i, r;
struct timespec ts;
if (fdw->nkqevents)
sys_log(2, "fdwatch: nkqevents %d", fdw->nkqevents);
if (!timeout)
{
ts.tv_sec = 0;
ts.tv_nsec = 0;
r = kevent(fdw->kq, fdw->kqevents, fdw->nkqevents, fdw->kqrevents, fdw->nfiles, &ts);
}
else
{
ts.tv_sec = timeout->tv_sec;
ts.tv_nsec = timeout->tv_usec;
r = kevent(fdw->kq, fdw->kqevents, fdw->nkqevents, fdw->kqrevents, fdw->nfiles, &ts);
}
fdw->nkqevents = 0;
if (r == -1)
return -1;
memset(fdw->fd_event_idx, 0, sizeof(int) * fdw->nfiles);
for (i = 0; i < r; i++)
{
int fd = fdw->kqrevents[i].ident;
if (fd >= fdw->nfiles)
sys_err("ident overflow %d nfiles: %d", fdw->kqrevents[i].ident, fdw->nfiles);
else
{
if (fdw->kqrevents[i].filter == EVFILT_WRITE)
fdw->fd_event_idx[fd] = i;
}
}
return (r);
}
void fdwatch_register(LPFDWATCH fdw, int flag, int fd, int rw)
{
if (flag == EV_DELETE)
{
if (fdw->fd_rw[fd] & FDW_READ)
{
fdw->kqevents[fdw->nkqevents].ident = fd;
fdw->kqevents[fdw->nkqevents].flags = flag;
fdw->kqevents[fdw->nkqevents].filter = EVFILT_READ;
++fdw->nkqevents;
}
if (fdw->fd_rw[fd] & FDW_WRITE)
{
fdw->kqevents[fdw->nkqevents].ident = fd;
fdw->kqevents[fdw->nkqevents].flags = flag;
fdw->kqevents[fdw->nkqevents].filter = EVFILT_WRITE;
++fdw->nkqevents;
}
}
else
{
fdw->kqevents[fdw->nkqevents].ident = fd;
fdw->kqevents[fdw->nkqevents].flags = flag;
fdw->kqevents[fdw->nkqevents].filter = (rw == FDW_READ) ? EVFILT_READ : EVFILT_WRITE;
++fdw->nkqevents;
}
}
void fdwatch_clear_fd(LPFDWATCH fdw, socket_t fd)
{
fdw->fd_data[fd] = NULL;
fdw->fd_rw[fd] = 0;
}
void fdwatch_add_fd(LPFDWATCH fdw, socket_t fd, void * client_data, int rw, int oneshot)
{
int flag;
if (fd >= fdw->nfiles)
{
sys_err("fd overflow %d", fd);
return;
}
if (fdw->fd_rw[fd] & rw)
return;
fdw->fd_rw[fd] |= rw;
sys_log(2, "FDWATCH_REGISTER fdw %p fd %d rw %d data %p", fdw, fd, rw, client_data);
if (!oneshot)
flag = EV_ADD;
else
{
sys_log(2, "ADD ONESHOT fd_rw %d", fdw->fd_rw[fd]);
flag = EV_ADD | EV_ONESHOT;
fdw->fd_rw[fd] |= FDW_WRITE_ONESHOT;
}
fdw->fd_data[fd] = client_data;
fdwatch_register(fdw, flag, fd, rw);
}
void fdwatch_del_fd(LPFDWATCH fdw, socket_t fd)
{
fdwatch_register(fdw, EV_DELETE, fd, 0);
fdwatch_clear_fd(fdw, fd);
}
void fdwatch_clear_event(LPFDWATCH fdw, socket_t fd, unsigned int event_idx)
{
assert(event_idx < fdw->nfiles * 2);
if (fdw->kqrevents[event_idx].ident != fd)
return;
fdw->kqrevents[event_idx].ident = 0;
}
int fdwatch_check_event(LPFDWATCH fdw, socket_t fd, unsigned int event_idx)
{
assert(event_idx < fdw->nfiles * 2);
if (fdw->kqrevents[event_idx].ident != fd)
return 0;
if (fdw->kqrevents[event_idx].flags & EV_ERROR)
return FDW_EOF;
if (fdw->kqrevents[event_idx].flags & EV_EOF)
return FDW_EOF;
if (fdw->kqrevents[event_idx].filter == EVFILT_READ)
{
if (fdw->fd_rw[fd] & FDW_READ)
return FDW_READ;
}
else if (fdw->kqrevents[event_idx].filter == EVFILT_WRITE)
{
if (fdw->fd_rw[fd] & FDW_WRITE)
{
if (fdw->fd_rw[fd] & FDW_WRITE_ONESHOT)
fdw->fd_rw[fd] &= ~FDW_WRITE;
return FDW_WRITE;
}
}
else
sys_err("fdwatch_check_event: Unknown filter %d (descriptor %d)", fdw->kqrevents[event_idx].filter, fd);
return 0;
}
int fdwatch_get_ident(LPFDWATCH fdw, unsigned int event_idx)
{
assert(event_idx < fdw->nfiles * 2);
return fdw->kqrevents[event_idx].ident;
}
int fdwatch_get_buffer_size(LPFDWATCH fdw, socket_t fd)
{
int event_idx = fdw->fd_event_idx[fd];
if (fdw->kqrevents[event_idx].filter == EVFILT_WRITE)
return fdw->kqrevents[event_idx].data;
return 0;
}
void * fdwatch_get_client_data(LPFDWATCH fdw, unsigned int event_idx)
{
int fd;
assert(event_idx < fdw->nfiles * 2);
fd = fdw->kqrevents[event_idx].ident;
if (fd >= fdw->nfiles)
return NULL;
return (fdw->fd_data[fd]);
}
#else // ifndef __USE_SELECT__
#ifdef __WIN32__
static int win32_init_refcount = 0;
static bool win32_init()
{
if (win32_init_refcount > 0)
{
win32_init_refcount++;
return true;
}
WORD wVersion = MAKEWORD(2, 0);
WSADATA wsaData;
if (WSAStartup(wVersion, &wsaData) != 0)
return false;
win32_init_refcount++;
return true;
}
static void win32_deinit()
{
if (--win32_init_refcount <= 0)
WSACleanup();
}
#endif
LPFDWATCH fdwatch_new(int nfiles)
{
LPFDWATCH fdw;
#ifdef __WIN32__
if (!win32_init())
return NULL;
#endif
// nfiles value is limited to FD_SETSIZE (64)
CREATE(fdw, FDWATCH, 1);
fdw->nfiles = MIN(nfiles, FD_SETSIZE);
FD_ZERO(&fdw->rfd_set);
FD_ZERO(&fdw->wfd_set);
CREATE(fdw->select_fds, socket_t, nfiles);
CREATE(fdw->select_rfdidx, int, nfiles);
fdw->nselect_fds = 0;
CREATE(fdw->fd_rw, int, nfiles);
CREATE(fdw->fd_data, void*, nfiles);
return (fdw);
}
void fdwatch_delete(LPFDWATCH fdw)
{
free(fdw->fd_data);
free(fdw->fd_rw);
free(fdw->select_fds);
free(fdw->select_rfdidx);
free(fdw);
#ifdef __WIN32__
win32_deinit();
#endif
}
static int fdwatch_get_fdidx(LPFDWATCH fdw, socket_t fd) {
int i;
for (i = 0; i < fdw->nselect_fds; ++i) {
if (fdw->select_fds[i] == fd) {
return i;
}
}
return -1;
}
void fdwatch_add_fd(LPFDWATCH fdw, socket_t fd, void* client_data, int rw, int oneshot)
{
int idx = fdwatch_get_fdidx(fdw, fd);
if (idx < 0) {
if (fdw->nselect_fds >= fdw->nfiles) {
return;
}
idx = fdw->nselect_fds;
fdw->select_fds[fdw->nselect_fds++] = fd;
fdw->fd_rw[idx] = rw;
} else {
fdw->fd_rw[idx] |= rw;
}
fdw->fd_data[idx] = client_data;
if (rw & FDW_READ)
FD_SET(fd, &fdw->rfd_set);
if (rw & FDW_WRITE)
FD_SET(fd, &fdw->wfd_set);
}
void fdwatch_del_fd(LPFDWATCH fdw, socket_t fd)
{
if (fdw->nselect_fds <= 0) {
return;
}
int idx = fdwatch_get_fdidx(fdw, fd);
if (idx < 0) {
return;
}
--fdw->nselect_fds;
fdw->select_fds[idx] = fdw->select_fds[fdw->nselect_fds];
fdw->fd_data[idx] = fdw->fd_data[fdw->nselect_fds];
fdw->fd_rw[idx] = fdw->fd_rw[fdw->nselect_fds];
FD_CLR(fd, &fdw->rfd_set);
FD_CLR(fd, &fdw->wfd_set);
}
int fdwatch(LPFDWATCH fdw, struct timeval *timeout)
{
int r, i, event_idx;
struct timeval tv;
fdw->working_rfd_set = fdw->rfd_set;
fdw->working_wfd_set = fdw->wfd_set;
if (!timeout)
{
tv.tv_sec = 0;
tv.tv_usec = 0;
r = select(0, &fdw->working_rfd_set, &fdw->working_wfd_set, (fd_set*) 0, &tv);
}
else
{
tv = *timeout;
r = select(0, &fdw->working_rfd_set, &fdw->working_wfd_set, (fd_set*) 0, &tv);
}
if (r == -1)
return -1;
event_idx = 0;
for (i = 0; i < fdw->nselect_fds; ++i)
{
if (fdwatch_check_fd(fdw, fdw->select_fds[i]))
fdw->select_rfdidx[event_idx++] = i;
}
return event_idx;
}
int fdwatch_check_fd(LPFDWATCH fdw, socket_t fd)
{
int idx = fdwatch_get_fdidx(fdw, fd);
if (idx < 0) {
return 0;
}
int result = 0;
if ((fdw->fd_rw[idx] & FDW_READ) && FD_ISSET(fd, &fdw->working_rfd_set)) {
result |= FDW_READ;
}
if ((fdw->fd_rw[idx] & FDW_WRITE) && FD_ISSET(fd, &fdw->working_wfd_set)) {
result |= FDW_WRITE;
}
return result;
}
void * fdwatch_get_client_data(LPFDWATCH fdw, unsigned int event_idx)
{
int idx = fdw->select_rfdidx[event_idx];
if (idx < 0 || fdw->nfiles <= idx) {
return NULL;
}
return fdw->fd_data[idx];
}
int fdwatch_get_ident(LPFDWATCH fdw, unsigned int event_idx)
{
int idx = fdw->select_rfdidx[event_idx];
if (idx < 0 || fdw->nfiles <= idx) {
return 0;
}
return (int)fdw->select_fds[idx];
}
void fdwatch_clear_event(LPFDWATCH fdw, socket_t fd, unsigned int event_idx)
{
int idx = fdw->select_rfdidx[event_idx];
if (idx < 0 || fdw->nfiles <= idx) {
return;
}
socket_t rfd = fdw->select_fds[idx];
if (fd != rfd) {
return;
}
FD_CLR(fd, &fdw->working_rfd_set);
FD_CLR(fd, &fdw->working_wfd_set);
}
int fdwatch_check_event(LPFDWATCH fdw, socket_t fd, unsigned int event_idx)
{
int idx = fdw->select_rfdidx[event_idx];
if (idx < 0 || fdw->nfiles <= idx) {
return 0;
}
socket_t rfd = fdw->select_fds[idx];
if (fd != rfd) {
return 0;
}
int result = fdwatch_check_fd(fdw, fd);
if (result & FDW_READ) {
return FDW_READ;
} else if (result & FDW_WRITE) {
return FDW_WRITE;
}
return 0;
}
int fdwatch_get_buffer_size(LPFDWATCH fdw, socket_t fd)
{
return INT_MAX; // XXX TODO
}
#endif

234
libthecore/src/gost.c Normal file
View File

@ -0,0 +1,234 @@
#include "stdafx.h"
/*
static unsigned char const k8[16] = { 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 };
static unsigned char const k7[16] = { 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 };
static unsigned char const k6[16] = { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 };
static unsigned char const k5[16] = { 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15 };
static unsigned char const k4[16] = { 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9 };
static unsigned char const k3[16] = { 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11 };
static unsigned char const k2[16] = { 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 };
static unsigned char const k1[16] = { 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 };
*/
static unsigned char const k8[16] = { 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 };
static unsigned char const k7[16] = { 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5 };
static unsigned char const k6[16] = { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 };
static unsigned char const k5[16] = { 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9 };
static unsigned char const k4[16] = { 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 };
static unsigned char const k3[16] = { 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 };
static unsigned char const k2[16] = { 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 };
static unsigned char const k1[16] = { 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8 };
/* Byte-at-a-time substitution boxes */
static unsigned char k87[256];
static unsigned char k65[256];
static unsigned char k43[256];
static unsigned char k21[256];
void GOST_Init()
{
int i;
for (i = 0; i < 256; i++)
{
k87[i] = k8[i >> 4] << 4 | k7[i & 15];
k65[i] = k6[i >> 4] << 4 | k5[i & 15];
k43[i] = k4[i >> 4] << 4 | k3[i & 15];
k21[i] = k2[i >> 4] << 4 | k1[i & 15];
}
}
INLINE static DWORD f(DWORD x)
{
x = k87[x >> 24 & 255] << 24 | k65[x >> 16 & 255] << 16 | k43[x >> 8 & 255] << 8 | k21[x & 255];
return x << 11 | x >> (32 - 11);
}
/*
static void GOST_ECB_Encrypt(DWORD * N1, DWORD * N2, const DWORD * KeyAddress)
{
register DWORD n1, n2; // As named in the GOST
n1 = *N1;
n2 = *N2;
// Instead of swapping halves, swap names each round
n2 ^= f(n1+KeyAddress[0]);
n1 ^= f(n2+KeyAddress[1]);
n2 ^= f(n1+KeyAddress[2]);
n1 ^= f(n2+KeyAddress[3]);
n2 ^= f(n1+KeyAddress[4]);
n1 ^= f(n2+KeyAddress[5]);
n2 ^= f(n1+KeyAddress[6]);
n1 ^= f(n2+KeyAddress[7]);
n2 ^= f(n1+KeyAddress[0]);
n1 ^= f(n2+KeyAddress[1]);
n2 ^= f(n1+KeyAddress[2]);
n1 ^= f(n2+KeyAddress[3]);
n2 ^= f(n1+KeyAddress[4]);
n1 ^= f(n2+KeyAddress[5]);
n2 ^= f(n1+KeyAddress[6]);
n1 ^= f(n2+KeyAddress[7]);
n2 ^= f(n1+KeyAddress[0]);
n1 ^= f(n2+KeyAddress[1]);
n2 ^= f(n1+KeyAddress[2]);
n1 ^= f(n2+KeyAddress[3]);
n2 ^= f(n1+KeyAddress[4]);
n1 ^= f(n2+KeyAddress[5]);
n2 ^= f(n1+KeyAddress[6]);
n1 ^= f(n2+KeyAddress[7]);
n2 ^= f(n1+KeyAddress[7]);
n1 ^= f(n2+KeyAddress[6]);
n2 ^= f(n1+KeyAddress[5]);
n1 ^= f(n2+KeyAddress[4]);
n2 ^= f(n1+KeyAddress[3]);
n1 ^= f(n2+KeyAddress[2]);
n2 ^= f(n1+KeyAddress[1]);
n1 ^= f(n2+KeyAddress[0]);
// There is no swap after the last round
*N1 = n2;
*N2 = n1;
}
*/
int GOST_Encrypt(DWORD * DstBuffer, const DWORD * SrcBuffer, const DWORD * KeyAddress, DWORD Length, DWORD *IVector)
{
DWORD i;
DWORD N1,N2;
N1 = IVector[0];
N2 = IVector[1];
for (i = 0; i < (Length >> 2); i = i+2)
{
register DWORD n1, n2; // As named in the GOST
n1 = N1;
n2 = N2;
// Instead of swapping halves, swap names each round
n2 ^= f(n1+KeyAddress[0]);
n1 ^= f(n2+KeyAddress[1]);
n2 ^= f(n1+KeyAddress[2]);
n1 ^= f(n2+KeyAddress[3]);
n2 ^= f(n1+KeyAddress[4]);
n1 ^= f(n2+KeyAddress[5]);
n2 ^= f(n1+KeyAddress[6]);
n1 ^= f(n2+KeyAddress[7]);
n2 ^= f(n1+KeyAddress[0]);
n1 ^= f(n2+KeyAddress[1]);
n2 ^= f(n1+KeyAddress[2]);
n1 ^= f(n2+KeyAddress[3]);
n2 ^= f(n1+KeyAddress[4]);
n1 ^= f(n2+KeyAddress[5]);
n2 ^= f(n1+KeyAddress[6]);
n1 ^= f(n2+KeyAddress[7]);
n2 ^= f(n1+KeyAddress[0]);
n1 ^= f(n2+KeyAddress[1]);
n2 ^= f(n1+KeyAddress[2]);
n1 ^= f(n2+KeyAddress[3]);
n2 ^= f(n1+KeyAddress[4]);
n1 ^= f(n2+KeyAddress[5]);
n2 ^= f(n1+KeyAddress[6]);
n1 ^= f(n2+KeyAddress[7]);
n2 ^= f(n1+KeyAddress[7]);
n1 ^= f(n2+KeyAddress[6]);
n2 ^= f(n1+KeyAddress[5]);
n1 ^= f(n2+KeyAddress[4]);
n2 ^= f(n1+KeyAddress[3]);
n1 ^= f(n2+KeyAddress[2]);
n2 ^= f(n1+KeyAddress[1]);
n1 ^= f(n2+KeyAddress[0]);
N1 = n2;
N2 = n1;
//GOST_ECB_Encrypt(&N1, &N2, KeyAddress);
// XOR plaintext with initial vector,
// move rezult to ciphertext and to initial vector
DstBuffer[i] = SrcBuffer[i] ^ N1;
N1 = DstBuffer[i];
DstBuffer[i+1] = SrcBuffer[i+1] ^ N2;
N2 = DstBuffer[i+1];
}
return Length;
}
// ************ GOST CBC decryption **************
int GOST_Decrypt(DWORD * DstBuffer, const DWORD * SrcBuffer, const DWORD * KeyAddress, DWORD Length, DWORD *IVector)
{
DWORD i;
DWORD N1, N2, dwTmp;
N1 = IVector[0];
N2 = IVector[1];
for (i = 0; i < (Length >> 2); i = i + 2)
{
register DWORD n1, n2; // As named in the GOST
n1 = N1;
n2 = N2;
// Instead of swapping halves, swap names each round
n2 ^= f(n1+KeyAddress[0]);
n1 ^= f(n2+KeyAddress[1]);
n2 ^= f(n1+KeyAddress[2]);
n1 ^= f(n2+KeyAddress[3]);
n2 ^= f(n1+KeyAddress[4]);
n1 ^= f(n2+KeyAddress[5]);
n2 ^= f(n1+KeyAddress[6]);
n1 ^= f(n2+KeyAddress[7]);
n2 ^= f(n1+KeyAddress[0]);
n1 ^= f(n2+KeyAddress[1]);
n2 ^= f(n1+KeyAddress[2]);
n1 ^= f(n2+KeyAddress[3]);
n2 ^= f(n1+KeyAddress[4]);
n1 ^= f(n2+KeyAddress[5]);
n2 ^= f(n1+KeyAddress[6]);
n1 ^= f(n2+KeyAddress[7]);
n2 ^= f(n1+KeyAddress[0]);
n1 ^= f(n2+KeyAddress[1]);
n2 ^= f(n1+KeyAddress[2]);
n1 ^= f(n2+KeyAddress[3]);
n2 ^= f(n1+KeyAddress[4]);
n1 ^= f(n2+KeyAddress[5]);
n2 ^= f(n1+KeyAddress[6]);
n1 ^= f(n2+KeyAddress[7]);
n2 ^= f(n1+KeyAddress[7]);
n1 ^= f(n2+KeyAddress[6]);
n2 ^= f(n1+KeyAddress[5]);
n1 ^= f(n2+KeyAddress[4]);
n2 ^= f(n1+KeyAddress[3]);
n1 ^= f(n2+KeyAddress[2]);
n2 ^= f(n1+KeyAddress[1]);
n1 ^= f(n2+KeyAddress[0]);
// There is no swap after the last round
N1 = n2;
N2 = n1;
//GOST_ECB_Encrypt(&N1, &N2, KeyAddress);
// XOR encrypted text with encrypted initial vector (we get rezult - decrypted text),
// move encrypted text to new initial vector.
// We need dwTmp because SrcBuffer may be the same as DstBuffer
dwTmp = SrcBuffer[i] ^ N1;
N1 = SrcBuffer[i];
DstBuffer[i] = dwTmp;
dwTmp = SrcBuffer[i+1] ^ N2;
N2 = SrcBuffer[i+1];
DstBuffer[i+1] = dwTmp;
}
return Length;
}

411
libthecore/src/gost_old.c Normal file
View File

@ -0,0 +1,411 @@
/*
* The GOST 28147-89 cipher
*
* This is based on the 25 Movember 1993 draft translation
* by Aleksandr Malchik, with Whitfield Diffie, of the Government
* Standard of the U.S.S.R. GOST 28149-89, "Cryptographic Transformation
* Algorithm", effective 1 July 1990. (Whitfield.Diffie@eng.sun.com)
*
* That is a draft, and may contain errors, which will be faithfully
* reflected here, along with possible exciting new bugs.
*
* Some details have been cleared up by the paper "Soviet Encryption
* Algorithm" by Josef Pieprzyk and Leonid Tombak of the University
* of Wollongong, New South Wales. (josef/leo@cs.adfa.oz.au)
*
* The standard is written by A. Zabotin (project leader), G.P. Glazkov,
* and V.B. Isaeva. It was accepted and introduced into use by the
* action of the State Standards Committee of the USSR on 2 June 89 as
* No. 1409. It was to be reviewed in 1993, but whether anyone wishes
* to take on this obligation from the USSR is questionable.
*
* This code is placed in the public domain.
*/
/*
* If you read the standard, it belabors the point of copying corresponding
* bits from point A to point B quite a bit. It helps to understand that
* the standard is uniformly little-endian, although it numbers bits from
* 1 rather than 0, so bit n has value 2^(n-1). The least significant bit
* of the 32-bit words that are manipulated in the algorithm is the first,
* lowest-numbered, in the bit string.
*/
/* A 32-bit data type */
#ifdef __alpha /* Any other 64-bit machines? */
typedef unsigned int word32;
#else
typedef unsigned long word32;
#endif
/*
* The standard does not specify the contents of the 8 4 bit->4 bit
* substitution boxes, saying they're a parameter of the network
* being set up. For illustration purposes here, I have used
* the first rows of the 8 S-boxes from the DES. (Note that the
* DES S-boxes are numbered starting from 1 at the msb. In keeping
* with the rest of the GOST, I have used little-endian numbering.
* Thus, k8 is S-box 1.
*
* Obviously, a careful look at the cryptographic properties of the cipher
* must be undertaken before "production" substitution boxes are defined.
*
* The standard also does not specify a standard bit-string representation
* for the contents of these blocks.
*/
static unsigned char const k8[16] = { 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 };
static unsigned char const k7[16] = { 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 };
static unsigned char const k6[16] = { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 };
static unsigned char const k5[16] = { 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15 };
static unsigned char const k4[16] = { 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9 };
static unsigned char const k3[16] = { 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11 };
static unsigned char const k2[16] = { 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 };
static unsigned char const k1[16] = { 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 };
/* Byte-at-a-time substitution boxes */
static unsigned char k87[256];
static unsigned char k65[256];
static unsigned char k43[256];
static unsigned char k21[256];
/*
* Build byte-at-a-time subtitution tables.
* This must be called once for global setup.
*/
#include <stdio.h>
void kboxinit(void)
{
int i;
for (i = 0; i < 256; i++)
{
k87[i] = k8[i >> 4] << 4 | k7[i & 15];
k65[i] = k6[i >> 4] << 4 | k5[i & 15];
k43[i] = k4[i >> 4] << 4 | k3[i & 15];
k21[i] = k2[i >> 4] << 4 | k1[i & 15];
}
}
/*
* Do the substitution and rotation that are the core of the operation,
* like the expansion, substitution and permutation of the DES.
* It would be possible to perform DES-like optimisations and store
* the table entries as 32-bit words, already rotated, but the
* efficiency gain is questionable.
*
* This should be inlined for maximum speed
*/
#if __GNUC__
__inline__
#endif
static word32 f(word32 x)
{
/* Do substitutions */
#if 0
/* This is annoyingly slow */
x = k8[x>>28 & 15] << 28 | k7[x>>24 & 15] << 24 |
k6[x>>20 & 15] << 20 | k5[x>>16 & 15] << 16 |
k4[x>>12 & 15] << 12 | k3[x>> 8 & 15] << 8 |
k2[x>> 4 & 15] << 4 | k1[x & 15];
#else
/* This is faster */
x = k87[x>>24 & 255] << 24 | k65[x>>16 & 255] << 16 | k43[x>> 8 & 255] << 8 | k21[x & 255];
#endif
/* Rotate left 11 bits */
return x << 11 | x >> (32 - 11);
}
/*
* The GOST standard defines the input in terms of bits 1..64, with
* bit 1 being the lsb of in[0] and bit 64 being the msb of in[1].
*
* The keys are defined similarly, with bit 256 being the msb of key[7].
*/
void gostcrypt(word32 const in[2], word32 out[2], word32 const key[8])
{
register word32 n1, n2; /* As named in the GOST */
n1 = in[0];
n2 = in[1];
/* Instead of swapping halves, swap names each round */
n2 ^= f(n1+key[0]);
n1 ^= f(n2+key[1]);
n2 ^= f(n1+key[2]);
n1 ^= f(n2+key[3]);
n2 ^= f(n1+key[4]);
n1 ^= f(n2+key[5]);
n2 ^= f(n1+key[6]);
n1 ^= f(n2+key[7]);
n2 ^= f(n1+key[0]);
n1 ^= f(n2+key[1]);
n2 ^= f(n1+key[2]);
n1 ^= f(n2+key[3]);
n2 ^= f(n1+key[4]);
n1 ^= f(n2+key[5]);
n2 ^= f(n1+key[6]);
n1 ^= f(n2+key[7]);
n2 ^= f(n1+key[0]);
n1 ^= f(n2+key[1]);
n2 ^= f(n1+key[2]);
n1 ^= f(n2+key[3]);
n2 ^= f(n1+key[4]);
n1 ^= f(n2+key[5]);
n2 ^= f(n1+key[6]);
n1 ^= f(n2+key[7]);
n2 ^= f(n1+key[7]);
n1 ^= f(n2+key[6]);
n2 ^= f(n1+key[5]);
n1 ^= f(n2+key[4]);
n2 ^= f(n1+key[3]);
n1 ^= f(n2+key[2]);
n2 ^= f(n1+key[1]);
n1 ^= f(n2+key[0]);
/* There is no swap after the last round */
out[0] = n2;
out[1] = n1;
}
/*
* The key schedule is somewhat different for decryption.
* (The key table is used once forward and three times backward.)
* You could define an expanded key, or just write the code twice,
* as done here.
*/
void gostdecrypt(word32 const in[2], word32 out[2], word32 const key[8])
{
register word32 n1, n2; /* As named in the GOST */
n1 = in[0];
n2 = in[1];
n2 ^= f(n1+key[0]);
n1 ^= f(n2+key[1]);
n2 ^= f(n1+key[2]);
n1 ^= f(n2+key[3]);
n2 ^= f(n1+key[4]);
n1 ^= f(n2+key[5]);
n2 ^= f(n1+key[6]);
n1 ^= f(n2+key[7]);
n2 ^= f(n1+key[7]);
n1 ^= f(n2+key[6]);
n2 ^= f(n1+key[5]);
n1 ^= f(n2+key[4]);
n2 ^= f(n1+key[3]);
n1 ^= f(n2+key[2]);
n2 ^= f(n1+key[1]);
n1 ^= f(n2+key[0]);
n2 ^= f(n1+key[7]);
n1 ^= f(n2+key[6]);
n2 ^= f(n1+key[5]);
n1 ^= f(n2+key[4]);
n2 ^= f(n1+key[3]);
n1 ^= f(n2+key[2]);
n2 ^= f(n1+key[1]);
n1 ^= f(n2+key[0]);
n2 ^= f(n1+key[7]);
n1 ^= f(n2+key[6]);
n2 ^= f(n1+key[5]);
n1 ^= f(n2+key[4]);
n2 ^= f(n1+key[3]);
n1 ^= f(n2+key[2]);
n2 ^= f(n1+key[1]);
n1 ^= f(n2+key[0]);
out[0] = n2;
out[1] = n1;
}
/*
* The GOST "Output feedback" standard. It seems closer morally
* to the counter feedback mode some people have proposed for DES.
* The avoidance of the short cycles that are possible in OFB seems
* like a Good Thing.
*
* Calling it the stream mode makes more sense.
*
* The IV is encrypted with the key to produce the initial counter value.
* Then, for each output block, a constant is added, modulo 2^32-1
* (0 is represented as all-ones, not all-zeros), to each half of
* the counter, and the counter is encrypted to produce the value
* to XOR with the output.
*
* Len is the number of blocks. Sub-block encryption is
* left as an exercise for the user. Remember that the
* standard defines everything in a little-endian manner,
* so you want to use the low bit of gamma[0] first.
*
* OFB is, of course, self-inverse, so there is only one function.
*/
/* The constants for addition */
#define C1 0x01010104
#define C2 0x01010101
void gostofb(word32 const *in, word32 *out, int len, word32 const iv[2], word32 const key[8])
{
word32 temp[2]; /* Counter */
word32 gamma[2]; /* Output XOR value */
/* Compute starting value for counter */
gostcrypt(iv, temp, key);
while (len--)
{
temp[0] += C2;
if (temp[0] < C2) /* Wrap modulo 2^32? */
temp[0]++; /* Make it modulo 2^32-1 */
temp[1] += C1;
if (temp[1] < C1) /* Wrap modulo 2^32? */
temp[1]++; /* Make it modulo 2^32-1 */
gostcrypt(temp, gamma, key);
*out++ = *in++ ^ gamma[0];
*out++ = *in++ ^ gamma[1];
}
}
/*
* The CFB mode is just what you'd expect. Each block of ciphertext y[] is
* derived from the input x[] by the following pseudocode:
* y[i] = x[i] ^ gostcrypt(y[i-1])
* x[i] = y[i] ^ gostcrypt(y[i-1])
* Where y[-1] is the IV.
*
* The IV is modified in place. Again, len is in *blocks*.
*/
void gostcfbencrypt(word32 const *in, word32 *out, int len, word32 iv[2], word32 const key[8])
{
while (len--)
{
gostcrypt(iv, iv, key);
iv[0] = *out++ ^= iv[0];
iv[1] = *out++ ^= iv[1];
}
}
void gostcfbdecrypt(word32 const *in, word32 *out, int len, word32 iv[2], word32 const key[8])
{
word32 t;
while (len--)
{
gostcrypt(iv, iv, key);
t = *out;
*out++ ^= iv[0];
iv[0] = t;
t = *out;
*out++ ^= iv[1];
iv[1] = t;
}
}
/*
* The message suthetication code uses only 16 of the 32 rounds.
* There *is* a swap after the 16th round.
* The last block should be padded to 64 bits with zeros.
* len is the number of *blocks* in the input.
*/
void gostmac(word32 const *in, int len, word32 out[2], word32 const key[8])
{
register word32 n1, n2; /* As named in the GOST */
n1 = 0;
n2 = 0;
while (len--)
{
n1 ^= *in++;
n2 = *in++;
/* Instead of swapping halves, swap names each round */
n2 ^= f(n1+key[0]);
n1 ^= f(n2+key[1]);
n2 ^= f(n1+key[2]);
n1 ^= f(n2+key[3]);
n2 ^= f(n1+key[4]);
n1 ^= f(n2+key[5]);
n2 ^= f(n1+key[6]);
n1 ^= f(n2+key[7]);
n2 ^= f(n1+key[0]);
n1 ^= f(n2+key[1]);
n2 ^= f(n1+key[2]);
n1 ^= f(n2+key[3]);
n2 ^= f(n1+key[4]);
n1 ^= f(n2+key[5]);
n2 ^= f(n1+key[6]);
n1 ^= f(n2+key[7]);
}
out[0] = n1;
out[1] = n2;
}
#ifdef TEST
#include <stdio.h>
#include <stdlib.h>
/* Designed to cope with 15-bit rand() implementations */
#define RAND32 ((word32)rand() << 17 ^ (word32)rand() << 9 ^ rand())
int main(void)
{
word32 key[8];
word32 plain[2];
word32 cipher[2];
int i, j;
kboxinit();
printf("GOST 21847-89 test driver.\n");
for (i = 0; i < 1000; i++)
{
for (j = 0; j < 8; j++)
key[j] = RAND32;
plain[0] = RAND32;
plain[1] = RAND32;
printf("%3d\r", i);
fflush(stdout);
gostcrypt(plain, cipher, key);
for (j = 0; j < 99; j++)
gostcrypt(cipher, cipher, key);
for (j = 0; j < 100; j++)
gostdecrypt(cipher, cipher, key);
if (plain[0] != cipher[0] || plain[1] != cipher[1])
{
fprintf(stderr, "\nError! i = %d\n", i);
return 1;
}
}
printf("All tests passed.\n");
return 0;
}
#endif /* TEST */

123
libthecore/src/hangul.c Normal file
View File

@ -0,0 +1,123 @@
/*
* Filename: hangul.c
* Description: <20>ѱ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ҽ<EFBFBD>
*
* Author: <20><><EFBFBD><EFBFBD> aka. Cronan
*/
#define __LIBTHECORE__
#include "stdafx.h"
int is_hangul(const BYTE * str)
{
if (str[0] >= 0xb0 && str[0] <= 0xc8 && str[1] >= 0xa1 && str[1] <= 0xfe)
return 1;
return 0;
}
int check_han(const char *str)
{
int i, code;
if (!str || !*str)
return 0;
for (i = 0; str[i]; i += 2)
{
if (isnhspace(str[i]))
return 0;
if (isalpha(str[i]) || isdigit(str[i]))
continue;
code = str[i];
code += 256;
if (code < 176 || code > 200)
return 0;
}
return 1;
}
const char *first_han(const BYTE *str)
{
unsigned char high, low;
int len, i;
char *p = "<EFBFBD>׿<EFBFBD>";
static const char* wansung[] =
{
"<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>",
"<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>",
"<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>",
"ī", "Ÿ", "<EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD>", ""
};
static const char* johab[] =
{
"<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a",
"<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a",
"<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a", "<EFBFBD>a",
"<EFBFBD>a", "?", "?", "?", ""
};
len = strlen((const char*) str);
if (len < 2)
return p;
high = str[0];
low = str[1];
if (!is_hangul(str))
{
return p;
}
high = (KStbl[(high - 0xb0) * 94 + low - 0xa1] >> 8) & 0x7c;
for (i = 0; johab[i][0]; i++)
{
low = (johab[i][0] & 0x7f);
if (low == high)
return (wansung[i]);
}
return (p);
}
int under_han(const void * orig)
{
const BYTE * str = (const BYTE *) orig;
BYTE high, low;
int len;
len = strlen((const char*) str);
if (len < 2)
return 0;
if (str[len - 1] == ')')
{
while (str[len] != '(')
len--;
}
high = str[len - 2];
low = str[len - 1];
if (!is_hangul(&str[len - 2]))
return 0;
high = KStbl[(high - 0xb0) * 94 + low - 0xa1] & 0x1f;
if (high < 2)
return 0;
if (high > 28)
return 0;
return 1;
}

94
libthecore/src/heart.c Normal file
View File

@ -0,0 +1,94 @@
/*
* Filename: heart.c
* Description: fps <20><> <20>ѹ<EFBFBD><D1B9><EFBFBD> ȣ<><C8A3><EFBFBD>Ǵ<EFBFBD> "<22><><EFBFBD><EFBFBD>" <20>̴<EFBFBD>.
*
* Author: <20><><EFBFBD><EFBFBD> aka. Cronan
*/
#define __LIBTHECORE__
#include "stdafx.h"
extern volatile int num_events_called;
LPHEART heart_new(int opt_usec, HEARTFUNC func)
{
LPHEART ht;
if (!func)
{
sys_err("no function defined");
return NULL;
}
CREATE(ht, HEART, 1);
ht->func = func;
ht->opt_time.tv_sec = 0;
ht->opt_time.tv_usec = opt_usec;
ht->passes_per_sec = 1000000 / opt_usec;
gettimeofday(&ht->last_time, (struct timezone *) 0);
gettimeofday(&ht->before_sleep, (struct timezone *) 0);
return (ht);
}
void heart_delete(LPHEART ht)
{
free(ht);
}
int heart_idle(LPHEART ht)
{
struct timeval now, process_time, timeout, temp_time;
int missed_pulse;
gettimeofday(&ht->before_sleep, (struct timezone *) 0);
process_time = *timediff(&ht->before_sleep, &ht->last_time);
/*
* If we were asleep for more than one pass, count missed pulses and sleep
* until we're resynchronized with the next upcoming pulse.
*/
if (process_time.tv_sec == 0 && process_time.tv_usec < ht->opt_time.tv_usec)
{
missed_pulse = 0;
}
else
{
missed_pulse = process_time.tv_sec * ht->passes_per_sec;
missed_pulse += process_time.tv_usec / ht->opt_time.tv_usec;
}
// <20>ٺ<EFBFBD><D9BA><EFBFBD> pulse<73><65> <20><><EFBFBD>ƴµ<C6B4> <20><> <20>ð<EFBFBD><C3B0><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>...
// <20>޽<EFBFBD> fps <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ʋ<><C6B2><EFBFBD><EFBFBD><EFBFBD>ִµ<D6B4>, <20><>Ȯ<EFBFBD><C8AE> <20><><EFBFBD>ߴ<EFBFBD> <20><> <20>߿<EFBFBD><DFBF><EFBFBD><EFBFBD><EFBFBD> <20>ʾ<EFBFBD>.
if (missed_pulse > 0)
{
gettimeofday(&ht->last_time, (struct timezone *) 0);
}
else
{
/* Calculate the time we should wake up */
temp_time = *timediff(&ht->opt_time, &process_time);
ht->last_time = *timeadd(&ht->before_sleep, &temp_time);
/* Now keep sleeping until that time has come */
gettimeofday(&now, (struct timezone *) 0);
timeout = *timediff(&ht->last_time, &now);
thecore_sleep(&timeout);
}
++missed_pulse;
if (missed_pulse <= 0)
{
sys_err("missed_pulse is not positive! (%d)", missed_pulse);
missed_pulse = 1;
}
if (missed_pulse > (30 * ht->passes_per_sec))
{
sys_err("losing %d seconds. (lag occured)", missed_pulse / ht->passes_per_sec);
missed_pulse = 30 * ht->passes_per_sec;
}
return missed_pulse;
}

335
libthecore/src/kstbl.c Normal file
View File

@ -0,0 +1,335 @@
/*
* Filename: kstbl.c
* Description: <20>Ʒ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>δ<EFBFBD>.
*
* Author: <20><><EFBFBD><EFBFBD> aka. Cronan
*/
#define __LIBTHECORE__
unsigned KStbl[2350] =
{
/* KS <20>ϼ<EFBFBD><CFBC><EFBFBD> 2350<35><30><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ڵ<EFBFBD> */
0x8861,0x8862,0x8865,0x8868,0x8869,0x886a,0x886b,0x8871,
0x8873,0x8874,0x8875,0x8876,0x8877,0x8878,0x8879,0x887b,
0x887c,0x887d,0x8881,0x8882,0x8885,0x8889,0x8891,0x8893,
0x8895,0x8896,0x8897,0x88a1,0x88a2,0x88a5,0x88a9,0x88b5,
0x88b7,0x88c1,0x88c5,0x88c9,0x88e1,0x88e2,0x88e5,0x88e8,
0x88e9,0x88eb,0x88f1,0x88f3,0x88f5,0x88f6,0x88f7,0x88f8,
0x88fb,0x88fc,0x88fd,0x8941,0x8945,0x8949,0x8951,0x8953,
0x8955,0x8956,0x8957,0x8961,0x8962,0x8963,0x8965,0x8968,
0x8969,0x8971,0x8973,0x8975,0x8976,0x8977,0x897b,0x8981,
0x8985,0x8989,0x8993,0x8995,0x89a1,0x89a2,0x89a5,0x89a8,
0x89a9,0x89ab,0x89ad,0x89b0,0x89b1,0x89b3,0x89b5,0x89b7,
0x89b8,0x89c1,0x89c2,0x89c5,0x89c9,0x89cb,
0x89d1,0x89d3,0x89d5,0x89d7,0x89e1,0x89e5,0x89e9,0x89f1,
0x89f6,0x89f7,0x8a41,0x8a42,0x8a45,0x8a49,0x8a51,0x8a53,
0x8a55,0x8a57,0x8a61,0x8a65,0x8a69,0x8a73,0x8a75,0x8a81,
0x8a82,0x8a85,0x8a88,0x8a89,0x8a8a,0x8a8b,0x8a90,0x8a91,
0x8a93,0x8a95,0x8a97,0x8a98,0x8aa1,0x8aa2,0x8aa5,0x8aa9,
0x8ab6,0x8ab7,0x8ac1,0x8ad5,0x8ae1,0x8ae2,0x8ae5,0x8ae9,
0x8af1,0x8af3,0x8af5,0x8b41,0x8b45,0x8b49,0x8b61,0x8b62,
0x8b65,0x8b68,0x8b69,0x8b6a,0x8b71,0x8b73,0x8b75,0x8b77,
0x8b81,0x8ba1,0x8ba2,0x8ba5,0x8ba8,0x8ba9,0x8bab,0x8bb1,
0x8bb3,0x8bb5,0x8bb7,0x8bb8,0x8bbc,0x8c61,0x8c62,0x8c63,
0x8c65,0x8c69,0x8c6b,0x8c71,0x8c73,0x8c75,0x8c76,0x8c77,
0x8c7b,0x8c81,0x8c82,0x8c85,0x8c89,0x8c91,
0x8c93,0x8c95,0x8c96,0x8c97,0x8ca1,0x8ca2,0x8ca9,0x8ce1,
0x8ce2,0x8ce3,0x8ce5,0x8ce9,0x8cf1,0x8cf3,0x8cf5,0x8cf6,
0x8cf7,0x8d41,0x8d42,0x8d45,0x8d51,0x8d55,0x8d57,0x8d61,
0x8d65,0x8d69,0x8d75,0x8d76,0x8d7b,0x8d81,0x8da1,0x8da2,
0x8da5,0x8da7,0x8da9,0x8db1,0x8db3,0x8db5,0x8db7,0x8db8,
0x8db9,0x8dc1,0x8dc2,0x8dc9,0x8dd6,0x8dd7,0x8de1,0x8de2,
0x8df7,0x8e41,0x8e45,0x8e49,0x8e51,0x8e53,0x8e57,0x8e61,
0x8e81,0x8e82,0x8e85,0x8e89,0x8e90,0x8e91,0x8e93,0x8e95,
0x8e97,0x8e98,0x8ea1,0x8ea9,0x8eb6,0x8eb7,0x8ec1,0x8ec2,
0x8ec5,0x8ec9,0x8ed1,0x8ed3,0x8ed6,0x8ee1,0x8ee5,0x8ee9,
0x8ef1,0x8ef3,0x8f41,0x8f61,0x8f62,0x8f65,0x8f67,0x8f69,
0x8f6b,0x8f70,0x8f71,0x8f73,0x8f75,0x8f77,
0x8f7b,0x8fa1,0x8fa2,0x8fa5,0x8fa9,0x8fb1,0x8fb3,0x8fb5,
0x8fb7,0x9061,0x9062,0x9063,0x9065,0x9068,0x9069,0x906a,
0x906b,0x9071,0x9073,0x9075,0x9076,0x9077,0x9078,0x9079,
0x907b,0x907d,0x9081,0x9082,0x9085,0x9089,0x9091,0x9093,
0x9095,0x9096,0x9097,0x90a1,0x90a2,0x90a5,0x90a9,0x90b1,
0x90b7,0x90e1,0x90e2,0x90e4,0x90e5,0x90e9,0x90eb,0x90ec,
0x90f1,0x90f3,0x90f5,0x90f6,0x90f7,0x90fd,0x9141,0x9142,
0x9145,0x9149,0x9151,0x9153,0x9155,0x9156,0x9157,0x9161,
0x9162,0x9165,0x9169,0x9171,0x9173,0x9176,0x9177,0x917a,
0x9181,0x9185,0x91a1,0x91a2,0x91a5,0x91a9,0x91ab,0x91b1,
0x91b3,0x91b5,0x91b7,0x91bc,0x91bd,0x91c1,0x91c5,0x91c9,
0x91d6,0x9241,0x9245,0x9249,0x9251,0x9253,
0x9255,0x9261,0x9262,0x9265,0x9269,0x9273,0x9275,0x9277,
0x9281,0x9282,0x9285,0x9288,0x9289,0x9291,0x9293,0x9295,
0x9297,0x92a1,0x92b6,0x92c1,0x92e1,0x92e5,0x92e9,0x92f1,
0x92f3,0x9341,0x9342,0x9349,0x9351,0x9353,0x9357,0x9361,
0x9362,0x9365,0x9369,0x936a,0x936b,0x9371,0x9373,0x9375,
0x9377,0x9378,0x937c,0x9381,0x9385,0x9389,0x93a1,0x93a2,
0x93a5,0x93a9,0x93af,0x93b1,0x93b3,0x93b5,0x93b7,0x93bc,
0x9461,0x9462,0x9463,0x9465,0x9468,0x9469,0x946a,0x946b,
0x946c,0x9470,0x9471,0x9473,0x9475,0x9476,0x9477,0x9478,
0x9479,0x947d,0x9481,0x9482,0x9485,0x9489,0x9491,0x9493,
0x9495,0x9496,0x9497,0x94a1,0x94e1,0x94e2,0x94e3,0x94e5,
0x94e8,0x94e9,0x94eb,0x94ec,0x94f1,0x94f3,
0x94f5,0x94f7,0x94f9,0x94fc,0x9541,0x9542,0x9545,0x9549,
0x9551,0x9553,0x9555,0x9556,0x9557,0x9561,0x9565,0x9569,
0x9576,0x9577,0x9581,0x9585,0x95a1,0x95a2,0x95a5,0x95a8,
0x95a9,0x95ab,0x95ad,0x95b1,0x95b3,0x95b5,0x95b7,0x95b9,
0x95bb,0x95c1,0x95c5,0x95c9,0x95e1,0x95f6,0x9641,0x9645,
0x9649,0x9651,0x9653,0x9655,0x9661,0x9681,0x9682,0x9685,
0x9689,0x9691,0x9693,0x9695,0x9697,0x96a1,0x96b6,0x96c1,
0x96d7,0x96e1,0x96e5,0x96e9,0x96f3,0x96f5,0x96f7,0x9741,
0x9745,0x9749,0x9751,0x9757,0x9761,0x9762,0x9765,0x9768,
0x9769,0x976b,0x9771,0x9773,0x9775,0x9777,0x9781,0x97a1,
0x97a2,0x97a5,0x97a8,0x97a9,0x97b1,0x97b3,0x97b5,0x97b6,
0x97b7,0x97b8,0x9861,0x9862,0x9865,0x9869,
0x9871,0x9873,0x9875,0x9876,0x9877,0x987d,0x9881,0x9882,
0x9885,0x9889,0x9891,0x9893,0x9895,0x9896,0x9897,0x98e1,
0x98e2,0x98e5,0x98e9,0x98eb,0x98ec,0x98f1,0x98f3,0x98f5,
0x98f6,0x98f7,0x98fd,0x9941,0x9942,0x9945,0x9949,0x9951,
0x9953,0x9955,0x9956,0x9957,0x9961,0x9976,0x99a1,0x99a2,
0x99a5,0x99a9,0x99b7,0x99c1,0x99c9,0x99e1,0x9a41,0x9a45,
0x9a81,0x9a82,0x9a85,0x9a89,0x9a90,0x9a91,0x9a97,0x9ac1,
0x9ae1,0x9ae5,0x9ae9,0x9af1,0x9af3,0x9af7,0x9b61,0x9b62,
0x9b65,0x9b68,0x9b69,0x9b71,0x9b73,0x9b75,0x9b81,0x9b85,
0x9b89,0x9b91,0x9b93,0x9ba1,0x9ba5,0x9ba9,0x9bb1,0x9bb3,
0x9bb5,0x9bb7,0x9c61,0x9c62,0x9c65,0x9c69,0x9c71,0x9c73,
0x9c75,0x9c76,0x9c77,0x9c78,0x9c7c,0x9c7d,
0x9c81,0x9c82,0x9c85,0x9c89,0x9c91,0x9c93,0x9c95,0x9c96,
0x9c97,0x9ca1,0x9ca2,0x9ca5,0x9cb5,0x9cb7,0x9ce1,0x9ce2,
0x9ce5,0x9ce9,0x9cf1,0x9cf3,0x9cf5,0x9cf6,0x9cf7,0x9cfd,
0x9d41,0x9d42,0x9d45,0x9d49,0x9d51,0x9d53,0x9d55,0x9d57,
0x9d61,0x9d62,0x9d65,0x9d69,0x9d71,0x9d73,0x9d75,0x9d76,
0x9d77,0x9d81,0x9d85,0x9d93,0x9d95,0x9da1,0x9da2,0x9da5,
0x9da9,0x9db1,0x9db3,0x9db5,0x9db7,0x9dc1,0x9dc5,0x9dd7,
0x9df6,0x9e41,0x9e45,0x9e49,0x9e51,0x9e53,0x9e55,0x9e57,
0x9e61,0x9e65,0x9e69,0x9e73,0x9e75,0x9e77,0x9e81,0x9e82,
0x9e85,0x9e89,0x9e91,0x9e93,0x9e95,0x9e97,0x9ea1,0x9eb6,
0x9ec1,0x9ee1,0x9ee2,0x9ee5,0x9ee9,0x9ef1,0x9ef5,0x9ef7,
0x9f41,0x9f42,0x9f45,0x9f49,0x9f51,0x9f53,
0x9f55,0x9f57,0x9f61,0x9f62,0x9f65,0x9f69,0x9f71,0x9f73,
0x9f75,0x9f77,0x9f78,0x9f7b,0x9f7c,0x9fa1,0x9fa2,0x9fa5,
0x9fa9,0x9fb1,0x9fb3,0x9fb5,0x9fb7,0xa061,0xa062,0xa065,
0xa067,0xa068,0xa069,0xa06a,0xa06b,0xa071,0xa073,0xa075,
0xa077,0xa078,0xa07b,0xa07d,0xa081,0xa082,0xa085,0xa089,
0xa091,0xa093,0xa095,0xa096,0xa097,0xa098,0xa0a1,0xa0a2,
0xa0a9,0xa0b7,0xa0e1,0xa0e2,0xa0e5,0xa0e9,0xa0eb,0xa0f1,
0xa0f3,0xa0f5,0xa0f7,0xa0f8,0xa0fd,0xa141,0xa142,0xa145,
0xa149,0xa151,0xa153,0xa155,0xa156,0xa157,0xa161,0xa162,
0xa165,0xa169,0xa175,0xa176,0xa177,0xa179,0xa181,0xa1a1,
0xa1a2,0xa1a4,0xa1a5,0xa1a9,0xa1ab,0xa1b1,0xa1b3,0xa1b5,
0xa1b7,0xa1c1,0xa1c5,0xa1d6,0xa1d7,0xa241,
0xa245,0xa249,0xa253,0xa255,0xa257,0xa261,0xa265,0xa269,
0xa273,0xa275,0xa281,0xa282,0xa283,0xa285,0xa288,0xa289,
0xa28a,0xa28b,0xa291,0xa293,0xa295,0xa297,0xa29b,0xa29d,
0xa2a1,0xa2a5,0xa2a9,0xa2b3,0xa2b5,0xa2c1,0xa2e1,0xa2e5,
0xa2e9,0xa341,0xa345,0xa349,0xa351,0xa355,0xa361,0xa365,
0xa369,0xa371,0xa375,0xa3a1,0xa3a2,0xa3a5,0xa3a8,0xa3a9,
0xa3ab,0xa3b1,0xa3b3,0xa3b5,0xa3b6,0xa3b7,0xa3b9,0xa3bb,
0xa461,0xa462,0xa463,0xa464,0xa465,0xa468,0xa469,0xa46a,
0xa46b,0xa46c,0xa471,0xa473,0xa475,0xa477,0xa47b,0xa481,
0xa482,0xa485,0xa489,0xa491,0xa493,0xa495,0xa496,0xa497,
0xa49b,0xa4a1,0xa4a2,0xa4a5,0xa4b3,0xa4e1,0xa4e2,0xa4e5,
0xa4e8,0xa4e9,0xa4eb,0xa4f1,0xa4f3,0xa4f5,
0xa4f7,0xa4f8,0xa541,0xa542,0xa545,0xa548,0xa549,0xa551,
0xa553,0xa555,0xa556,0xa557,0xa561,0xa562,0xa565,0xa569,
0xa573,0xa575,0xa576,0xa577,0xa57b,0xa581,0xa585,0xa5a1,
0xa5a2,0xa5a3,0xa5a5,0xa5a9,0xa5b1,0xa5b3,0xa5b5,0xa5b7,
0xa5c1,0xa5c5,0xa5d6,0xa5e1,0xa5f6,0xa641,0xa642,0xa645,
0xa649,0xa651,0xa653,0xa661,0xa665,0xa681,0xa682,0xa685,
0xa688,0xa689,0xa68a,0xa68b,0xa691,0xa693,0xa695,0xa697,
0xa69b,0xa69c,0xa6a1,0xa6a9,0xa6b6,0xa6c1,0xa6e1,0xa6e2,
0xa6e5,0xa6e9,0xa6f7,0xa741,0xa745,0xa749,0xa751,0xa755,
0xa757,0xa761,0xa762,0xa765,0xa769,0xa771,0xa773,0xa775,
0xa7a1,0xa7a2,0xa7a5,0xa7a9,0xa7ab,0xa7b1,0xa7b3,0xa7b5,
0xa7b7,0xa7b8,0xa7b9,0xa861,0xa862,0xa865,
0xa869,0xa86b,0xa871,0xa873,0xa875,0xa876,0xa877,0xa87d,
0xa881,0xa882,0xa885,0xa889,0xa891,0xa893,0xa895,0xa896,
0xa897,0xa8a1,0xa8a2,0xa8b1,0xa8e1,0xa8e2,0xa8e5,0xa8e8,
0xa8e9,0xa8f1,0xa8f5,0xa8f6,0xa8f7,0xa941,0xa957,0xa961,
0xa962,0xa971,0xa973,0xa975,0xa976,0xa977,0xa9a1,0xa9a2,
0xa9a5,0xa9a9,0xa9b1,0xa9b3,0xa9b7,0xaa41,0xaa61,0xaa77,
0xaa81,0xaa82,0xaa85,0xaa89,0xaa91,0xaa95,0xaa97,0xab41,
0xab57,0xab61,0xab65,0xab69,0xab71,0xab73,0xaba1,0xaba2,
0xaba5,0xaba9,0xabb1,0xabb3,0xabb5,0xabb7,0xac61,0xac62,
0xac64,0xac65,0xac68,0xac69,0xac6a,0xac6b,0xac71,0xac73,
0xac75,0xac76,0xac77,0xac7b,0xac81,0xac82,0xac85,0xac89,
0xac91,0xac93,0xac95,0xac96,0xac97,0xaca1,
0xaca2,0xaca5,0xaca9,0xacb1,0xacb3,0xacb5,0xacb7,0xacc1,
0xacc5,0xacc9,0xacd1,0xacd7,0xace1,0xace2,0xace3,0xace4,
0xace5,0xace8,0xace9,0xaceb,0xacec,0xacf1,0xacf3,0xacf5,
0xacf6,0xacf7,0xacfc,0xad41,0xad42,0xad45,0xad49,0xad51,
0xad53,0xad55,0xad56,0xad57,0xad61,0xad62,0xad65,0xad69,
0xad71,0xad73,0xad75,0xad76,0xad77,0xad81,0xad85,0xad89,
0xad97,0xada1,0xada2,0xada3,0xada5,0xada9,0xadab,0xadb1,
0xadb3,0xadb5,0xadb7,0xadbb,0xadc1,0xadc2,0xadc5,0xadc9,
0xadd7,0xade1,0xade5,0xade9,0xadf1,0xadf5,0xadf6,0xae41,
0xae45,0xae49,0xae51,0xae53,0xae55,0xae61,0xae62,0xae65,
0xae69,0xae71,0xae73,0xae75,0xae77,0xae81,0xae82,0xae85,
0xae88,0xae89,0xae91,0xae93,0xae95,0xae97,
0xae99,0xae9b,0xae9c,0xaea1,0xaeb6,0xaec1,0xaec2,0xaec5,
0xaec9,0xaed1,0xaed7,0xaee1,0xaee2,0xaee5,0xaee9,0xaef1,
0xaef3,0xaef5,0xaef7,0xaf41,0xaf42,0xaf49,0xaf51,0xaf55,
0xaf57,0xaf61,0xaf62,0xaf65,0xaf69,0xaf6a,0xaf71,0xaf73,
0xaf75,0xaf77,0xafa1,0xafa2,0xafa5,0xafa8,0xafa9,0xafb0,
0xafb1,0xafb3,0xafb5,0xafb7,0xafbc,0xb061,0xb062,0xb064,
0xb065,0xb069,0xb071,0xb073,0xb076,0xb077,0xb07d,0xb081,
0xb082,0xb085,0xb089,0xb091,0xb093,0xb096,0xb097,0xb0b7,
0xb0e1,0xb0e2,0xb0e5,0xb0e9,0xb0eb,0xb0f1,0xb0f3,0xb0f6,
0xb0f7,0xb141,0xb145,0xb149,0xb157,0xb1a1,0xb1a2,0xb1a5,
0xb1a8,0xb1a9,0xb1ab,0xb1b1,0xb1b3,0xb1b7,0xb1c1,0xb1c2,
0xb1c5,0xb1d6,0xb1e1,0xb1f6,0xb241,0xb245,
0xb249,0xb251,0xb253,0xb261,0xb281,0xb282,0xb285,0xb289,
0xb291,0xb293,0xb297,0xb2a1,0xb2b6,0xb2c1,0xb2e1,0xb2e5,
0xb357,0xb361,0xb362,0xb365,0xb369,0xb36b,0xb370,0xb371,
0xb373,0xb381,0xb385,0xb389,0xb391,0xb3a1,0xb3a2,0xb3a5,
0xb3a9,0xb3b1,0xb3b3,0xb3b5,0xb3b7,0xb461,0xb462,0xb465,
0xb466,0xb467,0xb469,0xb46a,0xb46b,0xb470,0xb471,0xb473,
0xb475,0xb476,0xb477,0xb47b,0xb47c,0xb481,0xb482,0xb485,
0xb489,0xb491,0xb493,0xb495,0xb496,0xb497,0xb4a1,0xb4a2,
0xb4a5,0xb4a9,0xb4ac,0xb4b1,0xb4b3,0xb4b5,0xb4b7,0xb4bb,
0xb4bd,0xb4c1,0xb4c5,0xb4c9,0xb4d3,0xb4e1,0xb4e2,0xb4e5,
0xb4e6,0xb4e8,0xb4e9,0xb4ea,0xb4eb,0xb4f1,0xb4f3,0xb4f4,
0xb4f5,0xb4f6,0xb4f7,0xb4f8,0xb4fa,0xb4fc,
0xb541,0xb542,0xb545,0xb549,0xb551,0xb553,0xb555,0xb557,
0xb561,0xb562,0xb563,0xb565,0xb569,0xb56b,0xb56c,0xb571,
0xb573,0xb574,0xb575,0xb576,0xb577,0xb57b,0xb57c,0xb57d,
0xb581,0xb585,0xb589,0xb591,0xb593,0xb595,0xb596,0xb5a1,
0xb5a2,0xb5a5,0xb5a9,0xb5aa,0xb5ab,0xb5ad,0xb5b0,0xb5b1,
0xb5b3,0xb5b5,0xb5b7,0xb5b9,0xb5c1,0xb5c2,0xb5c5,0xb5c9,
0xb5d1,0xb5d3,0xb5d5,0xb5d6,0xb5d7,0xb5e1,0xb5e2,0xb5e5,
0xb5f1,0xb5f5,0xb5f7,0xb641,0xb642,0xb645,0xb649,0xb651,
0xb653,0xb655,0xb657,0xb661,0xb662,0xb665,0xb669,0xb671,
0xb673,0xb675,0xb677,0xb681,0xb682,0xb685,0xb689,0xb68a,
0xb68b,0xb691,0xb693,0xb695,0xb697,0xb6a1,0xb6a2,0xb6a5,
0xb6a9,0xb6b1,0xb6b3,0xb6b6,0xb6b7,0xb6c1,
0xb6c2,0xb6c5,0xb6c9,0xb6d1,0xb6d3,0xb6d7,0xb6e1,0xb6e2,
0xb6e5,0xb6e9,0xb6f1,0xb6f3,0xb6f5,0xb6f7,0xb741,0xb742,
0xb745,0xb749,0xb751,0xb753,0xb755,0xb757,0xb759,0xb761,
0xb762,0xb765,0xb769,0xb76f,0xb771,0xb773,0xb775,0xb777,
0xb778,0xb779,0xb77a,0xb77b,0xb77c,0xb77d,0xb781,0xb785,
0xb789,0xb791,0xb795,0xb7a1,0xb7a2,0xb7a5,0xb7a9,0xb7aa,
0xb7ab,0xb7b0,0xb7b1,0xb7b3,0xb7b5,0xb7b6,0xb7b7,0xb7b8,
0xb7bc,0xb861,0xb862,0xb865,0xb867,0xb868,0xb869,0xb86b,
0xb871,0xb873,0xb875,0xb876,0xb877,0xb878,0xb881,0xb882,
0xb885,0xb889,0xb891,0xb893,0xb895,0xb896,0xb897,0xb8a1,
0xb8a2,0xb8a5,0xb8a7,0xb8a9,0xb8b1,0xb8b7,0xb8c1,0xb8c5,
0xb8c9,0xb8e1,0xb8e2,0xb8e5,0xb8e9,0xb8eb,
0xb8f1,0xb8f3,0xb8f5,0xb8f7,0xb8f8,0xb941,0xb942,0xb945,
0xb949,0xb951,0xb953,0xb955,0xb957,0xb961,0xb965,0xb969,
0xb971,0xb973,0xb976,0xb977,0xb981,0xb9a1,0xb9a2,0xb9a5,
0xb9a9,0xb9ab,0xb9b1,0xb9b3,0xb9b5,0xb9b7,0xb9b8,0xb9b9,
0xb9bd,0xb9c1,0xb9c2,0xb9c9,0xb9d3,0xb9d5,0xb9d7,0xb9e1,
0xb9f6,0xb9f7,0xba41,0xba45,0xba49,0xba51,0xba53,0xba55,
0xba57,0xba61,0xba62,0xba65,0xba77,0xba81,0xba82,0xba85,
0xba89,0xba8a,0xba8b,0xba91,0xba93,0xba95,0xba97,0xbaa1,
0xbab6,0xbac1,0xbae1,0xbae2,0xbae5,0xbae9,0xbaf1,0xbaf3,
0xbaf5,0xbb41,0xbb45,0xbb49,0xbb51,0xbb61,0xbb62,0xbb65,
0xbb69,0xbb71,0xbb73,0xbb75,0xbb77,0xbba1,0xbba2,0xbba5,
0xbba8,0xbba9,0xbbab,0xbbb1,0xbbb3,0xbbb5,
0xbbb7,0xbbb8,0xbbbb,0xbbbc,0xbc61,0xbc62,0xbc65,0xbc67,
0xbc69,0xbc6c,0xbc71,0xbc73,0xbc75,0xbc76,0xbc77,0xbc81,
0xbc82,0xbc85,0xbc89,0xbc91,0xbc93,0xbc95,0xbc96,0xbc97,
0xbca1,0xbca5,0xbcb7,0xbce1,0xbce2,0xbce5,0xbce9,0xbcf1,
0xbcf3,0xbcf5,0xbcf6,0xbcf7,0xbd41,0xbd57,0xbd61,0xbd76,
0xbda1,0xbda2,0xbda5,0xbda9,0xbdb1,0xbdb3,0xbdb5,0xbdb7,
0xbdb9,0xbdc1,0xbdc2,0xbdc9,0xbdd6,0xbde1,0xbdf6,0xbe41,
0xbe45,0xbe49,0xbe51,0xbe53,0xbe77,0xbe81,0xbe82,0xbe85,
0xbe89,0xbe91,0xbe93,0xbe97,0xbea1,0xbeb6,0xbeb7,0xbee1,
0xbf41,0xbf61,0xbf71,0xbf75,0xbf77,0xbfa1,0xbfa2,0xbfa5,
0xbfa9,0xbfb1,0xbfb3,0xbfb7,0xbfb8,0xbfbd,0xc061,0xc062,
0xc065,0xc067,0xc069,0xc071,0xc073,0xc075,
0xc076,0xc077,0xc078,0xc081,0xc082,0xc085,0xc089,0xc091,
0xc093,0xc095,0xc096,0xc097,0xc0a1,0xc0a5,0xc0a7,0xc0a9,
0xc0b1,0xc0b7,0xc0e1,0xc0e2,0xc0e5,0xc0e9,0xc0f1,0xc0f3,
0xc0f5,0xc0f6,0xc0f7,0xc141,0xc142,0xc145,0xc149,0xc151,
0xc153,0xc155,0xc157,0xc161,0xc165,0xc176,0xc181,0xc185,
0xc197,0xc1a1,0xc1a2,0xc1a5,0xc1a9,0xc1b1,0xc1b3,0xc1b5,
0xc1b7,0xc1c1,0xc1c5,0xc1c9,0xc1d7,0xc241,0xc245,0xc249,
0xc251,0xc253,0xc255,0xc257,0xc261,0xc271,0xc281,0xc282,
0xc285,0xc289,0xc291,0xc293,0xc295,0xc297,0xc2a1,0xc2b6,
0xc2c1,0xc2c5,0xc2e1,0xc2e5,0xc2e9,0xc2f1,0xc2f3,0xc2f5,
0xc2f7,0xc341,0xc345,0xc349,0xc351,0xc357,0xc361,0xc362,
0xc365,0xc369,0xc371,0xc373,0xc375,0xc377,
0xc3a1,0xc3a2,0xc3a5,0xc3a8,0xc3a9,0xc3aa,0xc3b1,0xc3b3,
0xc3b5,0xc3b7,0xc461,0xc462,0xc465,0xc469,0xc471,0xc473,
0xc475,0xc477,0xc481,0xc482,0xc485,0xc489,0xc491,0xc493,
0xc495,0xc496,0xc497,0xc4a1,0xc4a2,0xc4b7,0xc4e1,0xc4e2,
0xc4e5,0xc4e8,0xc4e9,0xc4f1,0xc4f3,0xc4f5,0xc4f6,0xc4f7,
0xc541,0xc542,0xc545,0xc549,0xc551,0xc553,0xc555,0xc557,
0xc561,0xc565,0xc569,0xc571,0xc573,0xc575,0xc576,0xc577,
0xc581,0xc5a1,0xc5a2,0xc5a5,0xc5a9,0xc5b1,0xc5b3,0xc5b5,
0xc5b7,0xc5c1,0xc5c2,0xc5c5,0xc5c9,0xc5d1,0xc5d7,0xc5e1,
0xc5f7,0xc641,0xc649,0xc661,0xc681,0xc682,0xc685,0xc689,
0xc691,0xc693,0xc695,0xc697,0xc6a1,0xc6a5,0xc6a9,0xc6b7,
0xc6c1,0xc6d7,0xc6e1,0xc6e2,0xc6e5,0xc6e9,
0xc6f1,0xc6f3,0xc6f5,0xc6f7,0xc741,0xc745,0xc749,0xc751,
0xc761,0xc762,0xc765,0xc769,0xc771,0xc773,0xc777,0xc7a1,
0xc7a2,0xc7a5,0xc7a9,0xc7b1,0xc7b3,0xc7b5,0xc7b7,0xc861,
0xc862,0xc865,0xc869,0xc86a,0xc871,0xc873,0xc875,0xc876,
0xc877,0xc881,0xc882,0xc885,0xc889,0xc891,0xc893,0xc895,
0xc896,0xc897,0xc8a1,0xc8b7,0xc8e1,0xc8e2,0xc8e5,0xc8e9,
0xc8eb,0xc8f1,0xc8f3,0xc8f5,0xc8f6,0xc8f7,0xc941,0xc942,
0xc945,0xc949,0xc951,0xc953,0xc955,0xc957,0xc961,0xc965,
0xc976,0xc981,0xc985,0xc9a1,0xc9a2,0xc9a5,0xc9a9,0xc9b1,
0xc9b3,0xc9b5,0xc9b7,0xc9bc,0xc9c1,0xc9c5,0xc9e1,0xca41,
0xca45,0xca55,0xca57,0xca61,0xca81,0xca82,0xca85,0xca89,
0xca91,0xca93,0xca95,0xca97,0xcaa1,0xcab6,
0xcac1,0xcae1,0xcae2,0xcae5,0xcae9,0xcaf1,0xcaf3,0xcaf7,
0xcb41,0xcb45,0xcb49,0xcb51,0xcb57,0xcb61,0xcb62,0xcb65,
0xcb68,0xcb69,0xcb6b,0xcb71,0xcb73,0xcb75,0xcb81,0xcb85,
0xcb89,0xcb91,0xcb93,0xcba1,0xcba2,0xcba5,0xcba9,0xcbb1,
0xcbb3,0xcbb5,0xcbb7,0xcc61,0xcc62,0xcc63,0xcc65,0xcc69,
0xcc6b,0xcc71,0xcc73,0xcc75,0xcc76,0xcc77,0xcc7b,0xcc81,
0xcc82,0xcc85,0xcc89,0xcc91,0xcc93,0xcc95,0xcc96,0xcc97,
0xcca1,0xcca2,0xcce1,0xcce2,0xcce5,0xcce9,0xccf1,0xccf3,
0xccf5,0xccf6,0xccf7,0xcd41,0xcd42,0xcd45,0xcd49,0xcd51,
0xcd53,0xcd55,0xcd57,0xcd61,0xcd65,0xcd69,0xcd71,0xcd73,
0xcd76,0xcd77,0xcd81,0xcd89,0xcd93,0xcd95,0xcda1,0xcda2,
0xcda5,0xcda9,0xcdb1,0xcdb3,0xcdb5,0xcdb7,
0xcdc1,0xcdd7,0xce41,0xce45,0xce61,0xce65,0xce69,0xce73,
0xce75,0xce81,0xce82,0xce85,0xce88,0xce89,0xce8b,0xce91,
0xce93,0xce95,0xce97,0xcea1,0xceb7,0xcee1,0xcee5,0xcee9,
0xcef1,0xcef5,0xcf41,0xcf45,0xcf49,0xcf51,0xcf55,0xcf57,
0xcf61,0xcf65,0xcf69,0xcf71,0xcf73,0xcf75,0xcfa1,0xcfa2,
0xcfa5,0xcfa9,0xcfb1,0xcfb3,0xcfb5,0xcfb7,0xd061,0xd062,
0xd065,0xd069,0xd06e,0xd071,0xd073,0xd075,0xd077,0xd081,
0xd082,0xd085,0xd089,0xd091,0xd093,0xd095,0xd096,0xd097,
0xd0a1,0xd0b7,0xd0e1,0xd0e2,0xd0e5,0xd0e9,0xd0eb,0xd0f1,
0xd0f3,0xd0f5,0xd0f7,0xd141,0xd142,0xd145,0xd149,0xd151,
0xd153,0xd155,0xd157,0xd161,0xd162,0xd165,0xd169,0xd171,
0xd173,0xd175,0xd176,0xd177,0xd181,0xd185,
0xd189,0xd193,0xd1a1,0xd1a2,0xd1a5,0xd1a9,0xd1ae,0xd1b1,
0xd1b3,0xd1b5,0xd1b7,0xd1bb,0xd1c1,0xd1c2,0xd1c5,0xd1c9,
0xd1d5,0xd1d7,0xd1e1,0xd1e2,0xd1e5,0xd1f5,0xd1f7,0xd241,
0xd242,0xd245,0xd249,0xd253,0xd255,0xd257,0xd261,0xd265,
0xd269,0xd273,0xd275,0xd281,0xd282,0xd285,0xd289,0xd28e,
0xd291,0xd295,0xd297,0xd2a1,0xd2a5,0xd2a9,0xd2b1,0xd2b7,
0xd2c1,0xd2c2,0xd2c5,0xd2c9,0xd2d7,0xd2e1,0xd2e2,0xd2e5,
0xd2e9,0xd2f1,0xd2f3,0xd2f5,0xd2f7,0xd341,0xd342,0xd345,
0xd349,0xd351,0xd355,0xd357,0xd361,0xd362,0xd365,0xd367,
0xd368,0xd369,0xd36a,0xd371,0xd373,0xd375,0xd377,0xd37b,
0xd381,0xd385,0xd389,0xd391,0xd393,0xd397,0xd3a1,0xd3a2,
0xd3a5,0xd3a9,0xd3b1,0xd3b3,0xd3b5,0xd3b7
};

459
libthecore/src/log.c Normal file
View File

@ -0,0 +1,459 @@
/*
* Filename: log.c
* Description: local log file <20><><EFBFBD><EFBFBD>
*
* Author: <20><><EFBFBD><EFBFBD> aka. Cronan
*/
#define __LIBTHECORE__
#include "stdafx.h"
#ifndef __WIN32__
#define SYSLOG_FILENAME "syslog"
#define SYSERR_FILENAME "syserr"
#define PTS_FILENAME "PTS"
#else
#define SYSLOG_FILENAME "syslog.txt"
#define SYSERR_FILENAME "syserr.txt"
#define PTS_FILENAME "PTS.txt"
#endif
typedef struct log_file_s * LPLOGFILE;
typedef struct log_file_s LOGFILE;
struct log_file_s
{
char* filename;
FILE* fp;
int last_hour;
int last_day;
};
LPLOGFILE log_file_sys = NULL;
LPLOGFILE log_file_err = NULL;
LPLOGFILE log_file_pt = NULL;
static char log_dir[32] = { 0, };
unsigned int log_keep_days = 3;
// Internal functions
LPLOGFILE log_file_init(const char* filename, const char *openmode);
void log_file_destroy(LPLOGFILE logfile);
void log_file_rotate(LPLOGFILE logfile);
void log_file_check(LPLOGFILE logfile);
void log_file_set_dir(const char *dir);
static unsigned int log_level_bits = 0;
void log_set_level(unsigned int bit)
{
log_level_bits |= bit;
}
void log_unset_level(unsigned int bit)
{
log_level_bits &= ~bit;
}
void log_set_expiration_days(unsigned int days)
{
log_keep_days = days;
}
int log_get_expiration_days(void)
{
return log_keep_days;
}
int log_init(void)
{
log_file_set_dir("./log");
do
{
log_file_sys = log_file_init(SYSLOG_FILENAME, "a+");
if( NULL == log_file_sys ) break;
log_file_err = log_file_init(SYSERR_FILENAME, "a+");
if( NULL == log_file_err ) break;
log_file_pt = log_file_init(PTS_FILENAME, "w");
if( NULL == log_file_pt ) break;
return true;
}
while( false );
return false;
}
void log_destroy(void)
{
log_file_destroy(log_file_sys);
log_file_destroy(log_file_err);
log_file_destroy(log_file_pt);
log_file_sys = NULL;
log_file_err = NULL;
log_file_pt = NULL;
}
void log_rotate(void)
{
log_file_check(log_file_sys);
log_file_check(log_file_err);
log_file_check(log_file_pt);
log_file_rotate(log_file_sys);
}
#ifndef __WIN32__
void _sys_err(const char *func, int line, const char *format, ...)
{
va_list args;
time_t ct = time(0);
char *time_s = asctime(localtime(&ct));
char buf[1024 + 2]; // \n<><6E> <20><><EFBFBD>̱<EFBFBD> <20><><EFBFBD><EFBFBD>..
int len;
if (!log_file_err)
return;
time_s[strlen(time_s) - 1] = '\0';
len = snprintf(buf, 1024, "SYSERR: %-15.15s :: %s: ", time_s + 4, func);
buf[1025] = '\0';
if (len < 1024)
{
va_start(args, format);
vsnprintf(buf + len, 1024 - len, format, args);
va_end(args);
}
strcat(buf, "\n");
// log_file_err <20><> <20><><EFBFBD><EFBFBD>
fputs(buf, log_file_err->fp);
fflush(log_file_err->fp);
// log_file_sys <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
fputs(buf, log_file_sys->fp);
fflush(log_file_sys->fp);
}
#else
void _sys_err(const char *func, int line, const char *format, ...)
{
va_list args;
time_t ct = time(0);
char *time_s = asctime(localtime(&ct));
char buf[1024 + 2]; // \n<><6E> <20><><EFBFBD>̱<EFBFBD> <20><><EFBFBD><EFBFBD>..
int len;
if (!log_file_err)
return;
time_s[strlen(time_s) - 1] = '\0';
len = snprintf(buf, 1024, "SYSERR: %-15.15s :: %s: ", time_s + 4, func);
buf[1025] = '\0';
if (len < 1024)
{
va_start(args, format);
vsnprintf(buf + len, 1024 - len, format, args);
va_end(args);
}
strcat(buf, "\n");
// log_file_err <20><> <20><><EFBFBD><EFBFBD>
fputs(buf, log_file_err->fp);
fflush(log_file_err->fp);
// log_file_sys <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
fputs(buf, log_file_sys->fp);
fflush(log_file_sys->fp);
fputs(buf, stdout);
fflush(stdout);
}
#endif
static char sys_log_header_string[33] = { 0, };
void sys_log_header(const char *header)
{
strncpy(sys_log_header_string, header, 32);
}
void sys_log(unsigned int bit, const char *format, ...)
{
va_list args;
if (bit != 0 && !(log_level_bits & bit))
return;
if (log_file_sys)
{
time_t ct = time(0);
char *time_s = asctime(localtime(&ct));
fprintf(log_file_sys->fp, sys_log_header_string);
time_s[strlen(time_s) - 1] = '\0';
fprintf(log_file_sys->fp, "%-15.15s :: ", time_s + 4);
va_start(args, format);
vfprintf(log_file_sys->fp, format, args);
va_end(args);
fputc('\n', log_file_sys->fp);
fflush(log_file_sys->fp);
}
#ifndef __WIN32__
// log_level<65><6C> 1 <20>̻<EFBFBD><CCBB><EFBFBD> <20><><EFBFBD>쿡<EFBFBD><ECBFA1> <20>׽<EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD>찡 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> stdout<75><74><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
if (log_level_bits > 1)
{
#endif
fprintf(stdout, sys_log_header_string);
va_start(args, format);
vfprintf(stdout, format, args);
va_end(args);
fputc('\n', stdout);
fflush(stdout);
#ifndef __WIN32__
}
#endif
}
void pt_log(const char *format, ...)
{
va_list args;
if (!log_file_pt)
return;
va_start(args, format);
vfprintf(log_file_pt->fp, format, args);
va_end(args);
fputc('\n', log_file_pt->fp);
fflush(log_file_pt->fp);
}
LPLOGFILE log_file_init(const char * filename, const char * openmode)
{
LPLOGFILE logfile;
FILE * fp;
struct tm curr_tm;
time_t time_s;
time_s = time(0);
curr_tm = *localtime(&time_s);
fp = fopen(filename, openmode);
if (!fp)
return NULL;
logfile = (LPLOGFILE) malloc(sizeof(LOGFILE));
logfile->filename = strdup(filename);
logfile->fp = fp;
logfile->last_hour = curr_tm.tm_hour;
logfile->last_day = curr_tm.tm_mday;
return (logfile);
}
void log_file_destroy(LPLOGFILE logfile)
{
if (logfile == NULL) {
return;
}
if (logfile->filename)
{
free(logfile->filename);
logfile->filename = NULL;
}
if (logfile->fp)
{
fclose(logfile->fp);
logfile->fp = NULL;
}
free(logfile);
}
void log_file_check(LPLOGFILE logfile)
{
struct stat sb;
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD> <20>ٽ<EFBFBD> <20><><EFBFBD><EFBFBD>.
if (stat(logfile->filename, &sb) != 0 && errno == ENOENT)
{
fclose(logfile->fp);
logfile->fp = fopen(logfile->filename, "a+");
}
}
void log_file_delete_old(const char *filename)
{
struct stat sb;
int num1, num2;
char buf[32];
char system_cmd[64];
struct tm new_tm;
if (stat(filename, &sb) == -1)
{
perror("log_file_delete_old: stat");
return;
}
if (!S_ISDIR(sb.st_mode))
return;
new_tm = *tm_calc(NULL, -log_keep_days);
sprintf(buf, "%04d%02d%02d", new_tm.tm_year + 1900, new_tm.tm_mon + 1, new_tm.tm_mday);
num1 = atoi(buf);
#ifndef __WIN32__
{
struct dirent ** namelist;
int n;
n = scandir(filename, &namelist, 0, alphasort);
if (n < 0)
perror("scandir");
else
{
char name[MAXNAMLEN+1];
while (n-- > 0)
{
strncpy(name, namelist[n]->d_name, 255);
name[255] = '\0';
free(namelist[n]);
if (*name == '.')
continue;
if (!isdigit(*name))
continue;
num2 = atoi(name);
if (num2 <= num1)
{
sprintf(system_cmd, "rm -rf %s/%s", filename, name);
system(system_cmd);
sys_log(0, "%s: SYSTEM_CMD: %s", __FUNCTION__, system_cmd);
fprintf(stderr, "%s: SYSTEM_CMD: %s %s:%d %s:%d\n", __FUNCTION__, system_cmd, buf, num1, name, num2);
}
}
}
free(namelist);
}
#else
{
WIN32_FIND_DATA fdata;
HANDLE hFind;
if ((hFind = FindFirstFile(filename, &fdata)) != INVALID_HANDLE_VALUE)
{
do
{
if (!isdigit(*fdata.cFileName))
continue;
num2 = atoi(fdata.cFileName);
if (num2 <= num1)
{
sprintf(system_cmd, "del %s\\%s", filename, fdata.cFileName);
system(system_cmd);
sys_log(0, "SYSTEM_CMD: %s", system_cmd);
}
}
while (FindNextFile(hFind, &fdata));
}
}
#endif
}
void log_file_rotate(LPLOGFILE logfile)
{
struct tm curr_tm;
time_t time_s;
char dir[128];
char system_cmd[128];
time_s = time(0);
curr_tm = *localtime(&time_s);
if (curr_tm.tm_mday != logfile->last_day)
{
struct tm new_tm;
new_tm = *tm_calc(&curr_tm, -3);
#ifndef __WIN32__
sprintf(system_cmd, "rm -rf %s/%04d%02d%02d", log_dir, new_tm.tm_year + 1900, new_tm.tm_mon + 1, new_tm.tm_mday);
#else
sprintf(system_cmd, "del %s\\%04d%02d%02d", log_dir, new_tm.tm_year + 1900, new_tm.tm_mon + 1, new_tm.tm_mday);
#endif
system(system_cmd);
sys_log(0, "SYSTEM_CMD: %s", system_cmd);
logfile->last_day = curr_tm.tm_mday;
}
if (curr_tm.tm_hour != logfile->last_hour)
{
struct stat stat_buf;
snprintf(dir, 128, "%s/%04d%02d%02d", log_dir, curr_tm.tm_year + 1900, curr_tm.tm_mon + 1, curr_tm.tm_mday);
if (stat(dir, &stat_buf) != 0 || S_ISDIR(stat_buf.st_mode))
{
#ifdef __WIN32__
CreateDirectory(dir, NULL);
#else
mkdir(dir, S_IRWXU);
#endif
}
sys_log(0, "SYSTEM: LOG ROTATE (%04d-%02d-%02d %d)",
curr_tm.tm_year + 1900, curr_tm.tm_mon + 1, curr_tm.tm_mday, logfile->last_hour);
// <20>α<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ݰ<EFBFBD>
fclose(logfile->fp);
// <20>ű<EFBFBD><C5B1><EFBFBD>.
#ifndef __WIN32__
snprintf(system_cmd, 128, "mv %s %s/%s.%02d", logfile->filename, dir, logfile->filename, logfile->last_hour);
#else
snprintf(system_cmd, 128, "move %s %s\\%s.%02d", logfile->filename, dir, logfile->filename, logfile->last_hour);
#endif
system(system_cmd);
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ð<EFBFBD> <20><><EFBFBD><EFBFBD>
logfile->last_hour = curr_tm.tm_hour;
// <20>α<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٽ<EFBFBD> <20><><EFBFBD><EFBFBD>.
logfile->fp = fopen(logfile->filename, "a+");
}
}
void log_file_set_dir(const char *dir)
{
strcpy(log_dir, dir);
log_file_delete_old(log_dir);
}

124
libthecore/src/main.c Normal file
View File

@ -0,0 +1,124 @@
/*
* Filename: main.c
* Description: <20><><EFBFBD>̺귯<CCBA><EAB7AF> <20>ʱ<EFBFBD>ȭ/<2F><><EFBFBD><EFBFBD> <20><>
*
* Author: <20><><EFBFBD><EFBFBD> aka. Cronan
*/
#define __LIBTHECORE__
#include "stdafx.h"
#include "memory.h"
extern void GOST_Init();
LPHEART thecore_heart = NULL;
volatile int shutdowned = FALSE;
volatile int tics = 0;
unsigned int thecore_profiler[NUM_PF];
static int pid_init(void)
{
#ifdef __WIN32__
return true;
#else
FILE* fp;
if ((fp = fopen("pid", "w")))
{
fprintf(fp, "%d", getpid());
fclose(fp);
sys_err("\nStart of pid: %d\n", getpid());
}
else
{
printf("pid_init(): could not open file for writing. (filename: ./pid)");
sys_err("\nError writing pid file\n");
return false;
}
return true;
#endif
}
static void pid_deinit(void)
{
#ifdef __WIN32__
return;
#else
remove("./pid");
sys_err("\nEnd of pid\n");
#endif
}
int thecore_init(int fps, HEARTFUNC heartbeat_func)
{
#ifdef __WIN32__
srand(time(0));
#else
srandom(time(0) + getpid() + getuid());
srandomdev();
#endif
signal_setup();
if (!log_init() || !pid_init())
return false;
GOST_Init();
thecore_heart = heart_new(1000000 / fps, heartbeat_func);
return true;
}
void thecore_shutdown()
{
shutdowned = TRUE;
}
int thecore_idle(void)
{
thecore_tick();
if (shutdowned)
return 0;
int pulses;
DWORD t = get_dword_time();
if (!(pulses = heart_idle(thecore_heart)))
{
thecore_profiler[PF_IDLE] += (get_dword_time() - t);
return 0;
}
thecore_profiler[PF_IDLE] += (get_dword_time() - t);
return pulses;
}
void thecore_destroy(void)
{
pid_deinit();
log_destroy();
}
int thecore_pulse(void)
{
return (thecore_heart->pulse);
}
float thecore_pulse_per_second(void)
{
return ((float) thecore_heart->passes_per_sec);
}
float thecore_time(void)
{
return ((float) thecore_heart->pulse / (float) thecore_heart->passes_per_sec);
}
int thecore_is_shutdowned(void)
{
return shutdowned;
}
void thecore_tick(void)
{
++tics;
}

134
libthecore/src/memcpy.c Normal file
View File

@ -0,0 +1,134 @@
/*
(c) Copyright 2000-2002 convergence integrated media GmbH.
(c) Copyright 2002 convergence GmbH.
All rights reserved.
Written by Denis Oliver Kropp <dok@directfb.org>,
Andreas Hundt <andi@fischlustig.de> and
Sven Neumann <sven@convergence.de>.
Fast memcpy code was taken from xine (see below).
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
/*
* Copyright (C) 2001 the xine project
*
* This file is part of xine, a unix video player.
*
* xine is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* xine is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* These are the MMX/MMX2/SSE optimized versions of memcpy
*
* This code was adapted from Linux Kernel sources by Nick Kurshev to
* the mplayer program. (http://mplayer.sourceforge.net)
*
* Miguel Freitas split the #ifdefs into several specialized functions that
* are benchmarked at runtime by xine. Some original comments from Nick
* have been preserved documenting some MMX/SSE oddities.
* Also added kernel memcpy function that seems faster than glibc one.
*
*/
/* Original comments from mplayer (file: aclib.c) This part of code
was taken by me from Linux-2.4.3 and slightly modified for MMX, MMX2,
SSE instruction set. I have done it since linux uses page aligned
blocks but mplayer uses weakly ordered data and original sources can
not speedup them. Only using PREFETCHNTA and MOVNTQ together have
effect!
From IA-32 Intel Architecture Software Developer's Manual Volume 1,
Order Number 245470:
"10.4.6. Cacheability Control, Prefetch, and Memory Ordering Instructions"
Data referenced by a program can be temporal (data will be used
again) or non-temporal (data will be referenced once and not reused
in the immediate future). To make efficient use of the processor's
caches, it is generally desirable to cache temporal data and not
cache non-temporal data. Overloading the processor's caches with
non-temporal data is sometimes referred to as "polluting the
caches". The non-temporal data is written to memory with
Write-Combining semantics.
The PREFETCHh instructions permits a program to load data into the
processor at a suggested cache level, so that it is closer to the
processors load and store unit when it is needed. If the data is
already present in a level of the cache hierarchy that is closer to
the processor, the PREFETCHh instruction will not result in any data
movement. But we should you PREFETCHNTA: Non-temporal data fetch
data into location close to the processor, minimizing cache
pollution.
The MOVNTQ (store quadword using non-temporal hint) instruction
stores packed integer data from an MMX register to memory, using a
non-temporal hint. The MOVNTPS (store packed single-precision
floating-point values using non-temporal hint) instruction stores
packed floating-point data from an XMM register to memory, using a
non-temporal hint.
The SFENCE (Store Fence) instruction controls write ordering by
creating a fence for memory store operations. This instruction
guarantees that the results of every store instruction that precedes
the store fence in program order is globally visible before any
store instruction that follows the fence. The SFENCE instruction
provides an efficient way of ensuring ordering between procedures
that produce weakly-ordered data and procedures that consume that
data.
If you have questions please contact with me: Nick Kurshev:
nickols_k@mail.ru.
*/
/* mmx v.1 Note: Since we added alignment of destinition it speedups
of memory copying on PentMMX, Celeron-1 and P2 upto 12% versus
standard (non MMX-optimized) version.
Note: on K6-2+ it speedups memory copying upto 25% and
on K7 and P3 about 500% (5 times).
*/
/* Additional notes on gcc assembly and processors: [MF]
prefetch is specific for AMD processors, the intel ones should be
prefetch0, prefetch1, prefetch2 which are not recognized by my gcc.
prefetchnta is supported both on athlon and pentium 3.
therefore i will take off prefetchnta instructions from the mmx1
version to avoid problems on pentium mmx and k6-2.
quote of the day:
"Using prefetches efficiently is more of an art than a science"
*/
#ifndef __WIN32__
#include <string.h>
void *(*thecore_memcpy) (void * to, const void * from, size_t len) = memcpy;
#endif

91
libthecore/src/signal.c Normal file
View File

@ -0,0 +1,91 @@
/*
* Filename: signal.c
* Description: <20>ñ׳<C3B1> <20><><EFBFBD><EFBFBD> <20>Լ<EFBFBD>.
*
* Author: <20><><EFBFBD><EFBFBD> aka. Cronan
*/
#define __LIBTHECORE__
#include "stdafx.h"
#ifdef __WIN32__
void signal_setup() {}
void signal_timer_disable() {}
void signal_timer_enable(int timeout_seconds) {}
#elif __FreeBSD__
#define RETSIGTYPE void
RETSIGTYPE reap(int sig)
{
while (waitpid(-1, NULL, WNOHANG) > 0);
signal(SIGCHLD, reap);
}
RETSIGTYPE checkpointing(int sig)
{
if (!tics)
{
sys_err("CHECKPOINT shutdown: tics did not updated.");
abort();
}
else
tics = 0;
}
RETSIGTYPE hupsig(int sig)
{
shutdowned = TRUE;
sys_err("SIGHUP, SIGINT, SIGTERM signal has been received. shutting down.");
}
RETSIGTYPE usrsig(int sig)
{
core_dump();
}
void signal_timer_disable(void)
{
struct itimerval itime;
struct timeval interval;
interval.tv_sec = 0;
interval.tv_usec = 0;
itime.it_interval = interval;
itime.it_value = interval;
setitimer(ITIMER_VIRTUAL, &itime, NULL);
}
void signal_timer_enable(int sec)
{
struct itimerval itime;
struct timeval interval;
interval.tv_sec = sec;
interval.tv_usec = 0;
itime.it_interval = interval;
itime.it_value = interval;
setitimer(ITIMER_VIRTUAL, &itime, NULL);
}
void signal_setup(void)
{
signal_timer_enable(30);
signal(SIGVTALRM, checkpointing);
/* just to be on the safe side: */
signal(SIGHUP, hupsig);
signal(SIGCHLD, reap);
signal(SIGINT, hupsig);
signal(SIGTERM, hupsig);
signal(SIGPIPE, SIG_IGN);
signal(SIGALRM, SIG_IGN);
signal(SIGUSR1, usrsig);
}
#endif

547
libthecore/src/socket.c Normal file
View File

@ -0,0 +1,547 @@
/*
* Filename: socket.c
* Description: <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ҽ<EFBFBD>.
*
* Author: <20><><EFBFBD><EFBFBD> aka. Cronan
*/
#define __LIBTHECORE__
#include "stdafx.h"
/* Forwards */
void socket_lingeron(socket_t s);
void socket_lingeroff(socket_t s);
void socket_timeout(socket_t s, long sec, long usec);
void socket_reuse(socket_t s);
void socket_keepalive(socket_t s);
int socket_udp_read(socket_t desc, char * read_point, size_t space_left, struct sockaddr * from, socklen_t * fromlen)
{
/*
ssize_t recvfrom(int s, void * buf, size_t len, int flags, struct sockaddr * from, socklen_t * fromlen);
*/
ssize_t ret;
ret = recvfrom(desc, read_point, space_left, 0, from, fromlen);
return (ret);
}
int socket_read(socket_t desc, char* read_point, size_t space_left)
{
int ret;
ret = recv(desc, read_point, space_left, 0);
if (ret > 0)
return ret;
if (ret == 0) // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
return -1;
#ifdef EINTR /* Interrupted system call - various platforms */
if (errno == EINTR)
return (0);
#endif
#ifdef EAGAIN /* POSIX */
if (errno == EAGAIN)
return (0);
#endif
#ifdef EWOULDBLOCK /* BSD */
if (errno == EWOULDBLOCK)
return (0);
#endif /* EWOULDBLOCK */
#ifdef EDEADLK /* Macintosh */
if (errno == EDEADLK)
return (0);
#endif
#ifdef __WIN32__
int wsa_error = WSAGetLastError();
if (wsa_error == WSAEWOULDBLOCK) {
return 0;
}
sys_log(0, "socket_read: WSAGetLastError returned %d", wsa_error);
#endif
sys_err("about to lose connection");
return -1;
}
int socket_write_tcp(socket_t desc, const char *txt, int length)
{
int bytes_written = send(desc, txt, length, 0);
// <20><><EFBFBD><EFBFBD>
if (bytes_written > 0)
return (bytes_written);
if (bytes_written == 0)
return -1;
#ifdef EAGAIN /* POSIX */
if (errno == EAGAIN)
return 0;
#endif
#ifdef EWOULDBLOCK /* BSD */
if (errno == EWOULDBLOCK)
return 0;
#endif
#ifdef EDEADLK /* Macintosh */
if (errno == EDEADLK)
return 0;
#endif
#ifdef __WIN32__
int wsa_error = WSAGetLastError();
if (wsa_error == WSAEWOULDBLOCK) {
return 0;
}
sys_log(0, "socket_write_tcp: WSAGetLastError returned %d", wsa_error);
#endif
/* Looks like the error was fatal. Too bad. */
return -1;
}
int socket_write(socket_t desc, const char *data, size_t length)
{
size_t total;
int bytes_written;
total = length;
do
{
if ((bytes_written = socket_write_tcp(desc, data, total)) < 0)
{
#ifdef EWOULDBLOCK
if (errno == EWOULDBLOCK)
errno = EAGAIN;
#endif
if (errno == EAGAIN)
sys_err("socket write would block, about to close!");
else
sys_err("write to desc error"); // '<27><><EFBFBD><EFBFBD>' <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̴<EFBFBD>.
return -1;
}
else
{
data += bytes_written;
total -= bytes_written;
}
}
while (total > 0);
return 0;
}
int socket_bind(const char * ip, int port, int protocol)
{
int s;
#ifdef __WIN32
SOCKADDR_IN sa;
#else
struct sockaddr_in sa;
#endif
if ((s = socket(AF_INET, protocol, 0)) < 0)
{
sys_err("socket: %s", strerror(errno));
return -1;
}
socket_reuse(s);
#ifndef __WIN32__
socket_lingeroff(s);
#else
// Winsock2: SO_DONTLINGER, SO_KEEPALIVE, SO_LINGER, and SO_OOBINLINE are
// not supported on sockets of type SOCK_DGRAM
if (protocol == SOCK_STREAM) {
socket_lingeroff(s);
}
#endif
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>߿<EFBFBD><DFBF><EFBFBD><EFBFBD>θ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> BIND ip<69><70> INADDR_ANY<4E><59> <20><><EFBFBD><EFBFBD>
//(<28>׽<EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD>Ǽ<EFBFBD><C7BC><EFBFBD> <20><><EFBFBD><EFBFBD>)
#ifndef __WIN32__
sa.sin_addr.s_addr = inet_addr(ip);
#else
sa.sin_addr.s_addr = INADDR_ANY;
#endif
sa.sin_port = htons((unsigned short) port);
if (bind(s, (struct sockaddr *) &sa, sizeof(sa)) < 0)
{
sys_err("bind: %s", strerror(errno));
return -1;
}
socket_nonblock(s);
if (protocol == SOCK_STREAM)
{
sys_log(0, "SYSTEM: BINDING TCP PORT ON [%d] (fd %d)", port, s);
listen(s, SOMAXCONN);
}
else
sys_log(0, "SYSTEM: BINDING UDP PORT ON [%d] (fd %d)", port, s);
return s;
}
int socket_tcp_bind(const char * ip, int port)
{
return socket_bind(ip, port, SOCK_STREAM);
}
int socket_udp_bind(const char * ip, int port)
{
return socket_bind(ip, port, SOCK_DGRAM);
}
void socket_close(socket_t s)
{
#ifdef __WIN32__
closesocket(s);
#else
close(s);
#endif
}
socket_t socket_accept(socket_t s, struct sockaddr_in *peer)
{
socket_t desc;
socklen_t i;
i = sizeof(*peer);
if ((desc = accept(s, (struct sockaddr *) peer, &i)) == -1)
{
sys_err("accept: %s (fd %d)", strerror(errno), s);
return -1;
}
if (desc >= 65500)
{
sys_err("SOCKET FD 65500 LIMIT! %d", desc);
socket_close(s);
return -1;
}
socket_nonblock(desc);
socket_lingeroff(desc);
return (desc);
}
socket_t socket_connect(const char* host, WORD port)
{
socket_t s = 0;
struct sockaddr_in server_addr;
int rslt;
/* <20><><EFBFBD><EFBFBD><EFBFBD>ּ<EFBFBD> <20><><EFBFBD><EFBFBD>ü <20>ʱ<EFBFBD>ȭ */
memset(&server_addr, 0, sizeof(server_addr));
if (isdigit(*host))
server_addr.sin_addr.s_addr = inet_addr(host);
else
{
struct hostent *hp;
if ((hp = gethostbyname(host)) == NULL)
{
sys_err("socket_connect(): can not connect to %s:%d", host, port);
return -1;
}
thecore_memcpy((char* ) &server_addr.sin_addr, hp->h_addr, sizeof(server_addr.sin_addr));
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port);
if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
perror("socket");
return -1;
}
socket_keepalive(s);
socket_sndbuf(s, 233016);
socket_rcvbuf(s, 233016);
socket_timeout(s, 10, 0);
socket_lingeron(s);
/* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>û */
if ((rslt = connect(s, (struct sockaddr *) &server_addr, sizeof(server_addr))) < 0)
{
socket_close(s);
#ifdef __WIN32__
switch (WSAGetLastError())
#else
switch (rslt)
#endif
{
#ifdef __WIN32__
case WSAETIMEDOUT:
#else
case EINTR:
#endif
sys_err("HOST %s:%d connection timeout.", host, port);
break;
#ifdef __WIN32__
case WSAECONNREFUSED:
#else
case ECONNREFUSED:
#endif
sys_err("HOST %s:%d port is not opened. connection refused.", host, port);
break;
#ifdef __WIN32__
case WSAENETUNREACH:
#else
case ENETUNREACH:
#endif
sys_err("HOST %s:%d is not reachable from this host.", host, port);
break;
default:
sys_err("HOST %s:%d, could not connect.", host, port);
break;
}
perror("connect");
return (-1);
}
return (s);
}
#ifndef __WIN32__
#ifndef O_NONBLOCK
#define O_NONBLOCK O_NDELAY
#endif
void socket_nonblock(socket_t s)
{
int flags;
flags = fcntl(s, F_GETFL, 0);
flags |= O_NONBLOCK;
if (fcntl(s, F_SETFL, flags) < 0)
{
sys_err("fcntl: nonblock: %s", strerror(errno));
return;
}
}
void socket_block(socket_t s)
{
int flags;
flags = fcntl(s, F_GETFL, 0);
flags &= ~O_NONBLOCK;
if (fcntl(s, F_SETFL, flags) < 0)
{
sys_err("fcntl: nonblock: %s", strerror(errno));
return;
}
}
#else
void socket_nonblock(socket_t s)
{
unsigned long val = 1;
ioctlsocket(s, FIONBIO, &val);
}
void socket_block(socket_t s)
{
unsigned long val = 0;
ioctlsocket(s, FIONBIO, &val);
}
#endif
void socket_dontroute(socket_t s)
{
int set;
if (setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (const char *) &set, sizeof(int)) < 0)
{
sys_err("setsockopt: dontroute: %s", strerror(errno));
socket_close(s);
return;
}
}
void socket_lingeroff(socket_t s)
{
#ifdef __WIN32__
int linger;
linger = 0;
#else
struct linger linger;
linger.l_onoff = 0;
linger.l_linger = 0;
#endif
if (setsockopt(s, SOL_SOCKET, SO_LINGER, (const char*) &linger, sizeof(linger)) < 0)
{
sys_err("setsockopt: linger: %s", strerror(errno));
socket_close(s);
return;
}
}
void socket_lingeron(socket_t s)
{
#ifdef __WIN32__
int linger;
linger = 0;
#else
struct linger linger;
linger.l_onoff = 1;
linger.l_linger = 0;
#endif
if (setsockopt(s, SOL_SOCKET, SO_LINGER, (const char*) &linger, sizeof(linger)) < 0)
{
sys_err("setsockopt: linger: %s", strerror(errno));
socket_close(s);
return;
}
}
void socket_rcvbuf(socket_t s, unsigned int opt)
{
socklen_t optlen;
optlen = sizeof(opt);
if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, (const char*) &opt, optlen) < 0)
{
sys_err("setsockopt: rcvbuf: %s", strerror(errno));
socket_close(s);
return;
}
opt = 0;
optlen = sizeof(opt);
if (getsockopt(s, SOL_SOCKET, SO_RCVBUF, (char*) &opt, &optlen) < 0)
{
sys_err("getsockopt: rcvbuf: %s", strerror(errno));
socket_close(s);
return;
}
sys_log(1, "SYSTEM: %d: receive buffer changed to %d", s, opt);
}
void socket_sndbuf(socket_t s, unsigned int opt)
{
socklen_t optlen;
optlen = sizeof(opt);
if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, (const char*) &opt, optlen) < 0)
{
sys_err("setsockopt: sndbuf: %s", strerror(errno));
return;
}
opt = 0;
optlen = sizeof(opt);
if (getsockopt(s, SOL_SOCKET, SO_SNDBUF, (char*) &opt, &optlen) < 0)
{
sys_err("getsockopt: sndbuf: %s", strerror(errno));
return;
}
sys_log(1, "SYSTEM: %d: send buffer changed to %d", s, opt);
}
// sec : seconds, usec : microseconds
void socket_timeout(socket_t s, long sec, long usec)
{
#ifndef __WIN32__
struct timeval rcvopt;
struct timeval sndopt;
socklen_t optlen = sizeof(rcvopt);
rcvopt.tv_sec = sndopt.tv_sec = sec;
rcvopt.tv_usec = sndopt.tv_usec = usec;
#else
socklen_t rcvopt, sndopt;
socklen_t optlen = sizeof(rcvopt);
sndopt = rcvopt = (sec * 1000) + (usec / 1000);
#endif
if (setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (const char*) &rcvopt, optlen) < 0)
{
sys_err("setsockopt: timeout: %s", strerror(errno));
socket_close(s);
return;
}
if (getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char*) &rcvopt, &optlen) < 0)
{
sys_err("getsockopt: timeout: %s", strerror(errno));
socket_close(s);
return;
}
optlen = sizeof(sndopt);
if (setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (const char*) &sndopt, optlen) < 0)
{
sys_err("setsockopt: timeout: %s", strerror(errno));
socket_close(s);
return;
}
if (getsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char*) &sndopt, &optlen) < 0)
{
sys_err("getsockopt: timeout: %s", strerror(errno));
socket_close(s);
return;
}
#ifndef __WIN32__
sys_log(1, "SYSTEM: %d: TIMEOUT RCV: %d.%d, SND: %d.%d", s, rcvopt.tv_sec, rcvopt.tv_usec, sndopt.tv_sec, sndopt.tv_usec);
#endif
}
void socket_reuse(socket_t s)
{
int opt = 1;
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const char*) &opt, sizeof(opt)) < 0)
{
sys_err("setsockopt: reuse: %s", strerror(errno));
socket_close(s);
return;
}
}
void socket_keepalive(socket_t s)
{
int opt = 1;
if (setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, (const char*) &opt, sizeof(opt)) < 0)
{
perror("setsockopt: keepalive");
socket_close(s);
return;
}
}

338
libthecore/src/tea.c Normal file
View File

@ -0,0 +1,338 @@
/*
* Filename: tea.c
* Description: TEA <20><>ȣȭ <20><><EFBFBD><EFBFBD>
*
* Author: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (aka. <20><><EFBFBD><EFBFBD>, Cronan), <20>ۿ<EFBFBD><DBBF><EFBFBD> (aka. myevan, <20><><EFBFBD>ڷ<EFBFBD>)
*/
#include "stdafx.h"
/*
* TEA Encryption Module Instruction
* Edited by <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> aka. <20><><EFBFBD><EFBFBD>, Cronan
*
* void tea_code(const DWORD sz, const DWORD sy, const DWORD *key, DWORD *dest)
* void tea_decode(const DWORD sz, const DWORD sy, const DWORD *key, DWORD *dest)
* 8<><38><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><>ȣ/<2F><>ȣȭ <20>Ҷ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ȴ<EFBFBD>. key <20><> 16 <20><><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20>Ѵ<EFBFBD>.
* sz, sy <20><> 8<><38><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
*
* int tea_decrypt(DWORD *dest, const DWORD *src, const DWORD *key, int size);
* int tea_encrypt(DWORD *dest, const DWORD *src, const DWORD *key, int size);
* <20>Ѳ<EFBFBD><D1B2><EFBFBD><EFBFBD><EFBFBD> 8 <20><><EFBFBD><EFBFBD>Ʈ <20>̻<EFBFBD><CCBB><EFBFBD> <20><>ȣ/<2F><>ȣȭ <20>Ҷ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>. <20><><EFBFBD><EFBFBD> size <20><>
* 8<><38> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ƴϸ<C6B4> 8<><38> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ũ<>⸦ "<22>÷<EFBFBD><C3B7><EFBFBD>" <20><>ȣȭ <20>Ѵ<EFBFBD>.
*
* ex. tea_code(pdwSrc[1], pdwSrc[0], pdwKey, pdwDest);
* tea_decrypt(pdwDest, pdwSrc, pdwKey, nSize);
*/
#define TEA_ROUND 32 // 32 <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϸ<EFBFBD>, <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
#define DELTA 0x9E3779B9 // DELTA <20><> <20>ٲ<EFBFBD><D9B2><EFBFBD> <20><><EFBFBD><EFBFBD>.
char tea_nilbuf[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
INLINE void tea_code(const DWORD sz, const DWORD sy, const DWORD *key, DWORD *dest)
{
register DWORD y = sy, z = sz, sum = 0;
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 1
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 2
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 3
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 4
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 5
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 6
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 7
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 8
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 9
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 10
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 11
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 12
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 13
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 14
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 15
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 16
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 17
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 18
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 19
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 20
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 21
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 22
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 23
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 24
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 25
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 26
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 27
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 28
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 29
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 30
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 31
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
y += ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]); // 32
sum += DELTA;
z += ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]);
*(dest++) = y;
*dest = z;
}
INLINE void tea_decode(const DWORD sz, const DWORD sy, const DWORD *key, DWORD *dest)
{
register DWORD y = sy, z = sz, sum = DELTA * TEA_ROUND;
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 1
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 2
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 3
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 4
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 5
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 6
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 7
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 8
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 9
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 10
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 11
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 12
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 13
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 14
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 15
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 16
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 17
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 18
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 19
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 20
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 21
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 22
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 23
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 24
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 25
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 26
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 27
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 28
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 29
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 30
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 31
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
z -= ((y << 4 ^ y >> 5) + y) ^ (sum + key[sum >> 11 & 3]); // 32
sum -= DELTA;
y -= ((z << 4 ^ z >> 5) + z) ^ (sum + key[sum & 3]);
*(dest++) = y;
*dest = z;
}
int TEA_Encrypt(DWORD *dest, const DWORD *src, const DWORD * key, int size)
{
int i;
int resize;
if (size % 8 != 0)
{
resize = size + 8 - (size % 8);
memset((char *) src + size, 0, resize - size);
}
else
resize = size;
for (i = 0; i < resize >> 3; i++, dest += 2, src += 2)
tea_code(*(src + 1), *src, key, dest);
return (resize);
}
int TEA_Decrypt(DWORD *dest, const DWORD *src, const DWORD * key, int size)
{
int i;
int resize;
if (size % 8 != 0)
resize = size + 8 - (size % 8);
else
resize = size;
for (i = 0; i < resize >> 3; i++, dest += 2, src += 2)
tea_decode(*(src + 1), *src, key, dest);
return (resize);
}

8682
libthecore/src/tea.s Normal file
View File

File diff suppressed because it is too large Load Diff

475
libthecore/src/utils.c Normal file
View File

@ -0,0 +1,475 @@
/*
* Filename: utils.c
* Description: <20><><EFBFBD><EFBFBD> <20><>ƿ<EFBFBD><C6BF>Ƽ
*
* Author: <20><><EFBFBD><EFBFBD> aka. Cronan
*/
#define __LIBTHECORE__
#include "stdafx.h"
static struct timeval null_time = { 0, 0 };
#define ishprint(x) ((((x) & 0xE0) > 0x90) || isprint(x))
void printdata(const unsigned char *data, int bytes)
{
int i, j, k;
const unsigned char *p;
fprintf(stderr, "------------------------------------------------------------------\n");
j = bytes;
while (1)
{
k = j >= 16 ? 16 : j;
p = data;
for (i = 0; i < 16; i++)
{
if (i >= k)
fprintf(stderr, " ");
else
fprintf(stderr, "%02x ", *p);
p++;
}
fprintf(stderr, "| ");
p = data;
for (i = 0; i < k; i++)
{
if (i >= k)
fprintf(stderr, " ");
else
{
fprintf(stderr, "%c", ishprint(*p) && ishprint(*(p+1)) ? *p : '.');
}
p++;
}
fprintf(stderr, "\n");
j -= 16;
data += 16;
if (j <= 0)
break;
}
fprintf(stderr, "------------------------------------------------------------------\n");
}
struct timeval * timediff(const struct timeval *a, const struct timeval *b)
{
static struct timeval rslt;
if (a->tv_sec < b->tv_sec)
return &null_time;
else if (a->tv_sec == b->tv_sec)
{
if (a->tv_usec < b->tv_usec)
return &null_time;
else
{
rslt.tv_sec = 0;
rslt.tv_usec = a->tv_usec - b->tv_usec;
return &rslt;
}
}
else
{ /* a->tv_sec > b->tv_sec */
rslt.tv_sec = a->tv_sec - b->tv_sec;
if (a->tv_usec < b->tv_usec)
{
rslt.tv_usec = a->tv_usec + 1000000 - b->tv_usec;
rslt.tv_sec--;
} else
rslt.tv_usec = a->tv_usec - b->tv_usec;
return &rslt;
}
}
struct timeval * timeadd(struct timeval *a, struct timeval *b)
{
static struct timeval rslt;
rslt.tv_sec = a->tv_sec + b->tv_sec;
rslt.tv_usec = a->tv_usec + b->tv_usec;
while (rslt.tv_usec >= 1000000)
{
rslt.tv_usec -= 1000000;
rslt.tv_sec++;
}
return &rslt;
}
char *time_str(time_t ct)
{
static char * time_s;
time_s = asctime(localtime(&ct));
time_s[strlen(time_s) - 6] = '\0';
time_s += 4;
return (time_s);
}
void trim_and_lower(const char * src, char * dest, size_t dest_size)
{
const char * tmp = src;
size_t len = 0;
if (!dest || dest_size == 0)
return;
if (!src)
{
*dest = '\0';
return;
}
// <20>տ<EFBFBD> <20><>ĭ <20>dz<EFBFBD> <20>ٱ<EFBFBD>
while (*tmp)
{
if (!isnhspace(*tmp))
break;
tmp++;
}
// \0 Ȯ<><C8AE>
--dest_size;
while (*tmp && len < dest_size)
{
*(dest++) = LOWER(*tmp); // LOWER<45><52> <20><>ũ<EFBFBD>ζ<EFBFBD> ++ <20><><EFBFBD><EFBFBD> <20>ȵ<EFBFBD>
++tmp;
++len;
}
*dest = '\0';
if (len > 0)
{
// <20>ڿ<EFBFBD> <20><>ĭ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
--dest;
while (*dest && isnhspace(*dest) && len--)
*(dest--) = '\0';
}
}
void lower_string(const char *src, char *dest, size_t dest_size)
{
const char* tmp = src;
size_t len = 0;
if (!dest || dest_size == 0)
return;
if (!src)
{
*dest = '\0';
return;
}
// \0 Ȯ<><C8AE>
--dest_size;
while (*tmp && len < dest_size)
{
*(dest++) = LOWER(*tmp); // LOWER<45><52> <20><>ũ<EFBFBD>ζ<EFBFBD> ++ <20><><EFBFBD><EFBFBD> <20>ȵ<EFBFBD>
++tmp;
++len;
}
*dest = '\0';
}
char *str_dup(const char *source)
{
char *new_line;
CREATE(new_line, char, strlen(source) + 1);
return (strcpy(new_line, source));
}
/* arg1 <20><> arg2 <20><> <20>մܰ<D5B4> <20><><EFBFBD><EFBFBD> <20><> 1 <20><> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>. */
int is_abbrev(char *arg1, char *arg2)
{
if (!*arg1)
return 0;
for (; *arg1 && *arg2; arg1++, arg2++)
if (LOWER(*arg1) != LOWER(*arg2))
return 0;
if (!*arg1)
return 1;
else
return 0;
}
int filesize(FILE *fp)
{
int pos;
int size;
pos = ftell(fp);
fseek(fp, 0, SEEK_END);
size = ftell(fp);
fseek(fp, pos, SEEK_SET);
return (size);
}
/* "Name : <20><><EFBFBD><EFBFBD>" <20><> <20><><EFBFBD><EFBFBD> "<22>׸<EFBFBD> : <20><>" <20><><EFBFBD><EFBFBD> <20>̷<EFBFBD><CCB7><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ڿ<EFBFBD><DABF><EFBFBD><EFBFBD><EFBFBD>
<20>׸<EFBFBD><D7B8><EFBFBD> token <20><><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD> value <20><> <20><><EFBFBD><EFBFBD><EFBFBD>Ͽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>. */
void parse_token(char *src, char *token, char *value)
{
char *tmp;
for (tmp = src; *tmp && *tmp != ':'; tmp++)
{
if (isnhspace(*tmp))
continue;
*(token++) = LOWER(*tmp);
}
*token = '\0';
for (tmp += 2; *tmp; tmp++)
{
if (*tmp == '\n' || *tmp == '\r')
continue;
*(value++) = *tmp;
}
*value = '\0';
}
struct tm * tm_calc(const struct tm * curr_tm, int days)
{
char yoon = FALSE;
static struct tm new_tm;
int monthdays[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
if (!curr_tm)
{
time_t time_s = time(0);
new_tm = *localtime(&time_s);
}
else
thecore_memcpy(&new_tm, curr_tm, sizeof(struct tm));
if (new_tm.tm_mon == 1)
{
if (!((new_tm.tm_year + 1900) % 4))
{
if (!((new_tm.tm_year + 1900) % 100))
{
if (!((new_tm.tm_year + 1900) % 400))
yoon = TRUE;
}
else
yoon = TRUE;
}
if (yoon)
new_tm.tm_mday += 1;
}
if (yoon)
monthdays[1] = 29;
else
monthdays[1] = 28;
new_tm.tm_mday += days;
if (new_tm.tm_mday <= 0)
{
new_tm.tm_mon--;
if (new_tm.tm_mon < 0)
{
new_tm.tm_year--;
new_tm.tm_mon = 11;
}
new_tm.tm_mday = monthdays[new_tm.tm_mon] + new_tm.tm_mday;
}
else if (new_tm.tm_mday > monthdays[new_tm.tm_mon])
{
new_tm.tm_mon++;
if (new_tm.tm_mon > 11)
{
new_tm.tm_year++;
new_tm.tm_mon = 0;
}
new_tm.tm_mday = monthdays[new_tm.tm_mon] - new_tm.tm_mday;
}
return (&new_tm);
}
int MIN(int a, int b)
{
return a < b ? a : b;
}
int MAX(int a, int b)
{
return a > b ? a : b;
}
int MINMAX(int min, int value, int max)
{
register int tv;
tv = (min > value ? min : value);
return (max < tv) ? max : tv;
}
DWORD thecore_random()
{
#ifdef __WIN32__
return rand();
#else
return random();
#endif
}
int number_ex(int from, int to, const char *file, int line)
{
if (from > to)
{
int tmp = from;
sys_err("number(): first argument is bigger than second argument %d -> %d, %s %d", from, to, file, line);
from = to;
to = tmp;
}
int returnValue = 0;
if ((to - from + 1) != 0)
returnValue = ((thecore_random() % (to - from + 1)) + from);
else
sys_err("number(): devided by 0");
return returnValue;
}
float fnumber(float from, float to)
{
return (((float)thecore_random() / (float)RAND_MAX) * (to - from)) + from;
}
#ifndef __WIN32__
void thecore_sleep(struct timeval* timeout)
{
if (select(0, (fd_set *) 0, (fd_set *) 0, (fd_set *) 0, timeout) < 0)
{
if (errno != EINTR)
{
sys_err("select sleep %s", strerror(errno));
return;
}
}
}
void thecore_msleep(DWORD dwMillisecond)
{
static struct timeval tv_sleep;
tv_sleep.tv_sec = dwMillisecond / 1000;
tv_sleep.tv_usec = dwMillisecond * 1000;
thecore_sleep(&tv_sleep);
}
void core_dump_unix(const char *who, WORD line)
{
sys_err("*** Dumping Core %s:%d ***", who, line);
fflush(stdout);
fflush(stderr);
if (fork() == 0)
abort();
}
/*
uint64_t rdtsc()
{
uint64_t x;
__asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
return x;
}
*/
#else
void thecore_sleep(struct timeval* timeout)
{
Sleep(timeout->tv_sec * 1000 + timeout->tv_usec / 1000);
}
void thecore_msleep(DWORD dwMillisecond)
{
Sleep(dwMillisecond);
}
void gettimeofday(struct timeval* t, struct timezone* dummy)
{
DWORD millisec = GetTickCount();
t->tv_sec = (millisec / 1000);
t->tv_usec = (millisec % 1000) * 1000;
}
void core_dump_unix(const char *who, WORD line)
{
}
#endif
float get_float_time()
{
struct timeval tv;
gettimeofday(&tv, NULL);
tv.tv_sec -= 1057699978;
return ((float) tv.tv_sec + ((float) tv.tv_usec / 1000000.0f));
}
static DWORD get_boot_sec()
{
static struct timeval tv_boot = {0L, 0L};
if (tv_boot.tv_sec == 0)
gettimeofday(&tv_boot, NULL);
return tv_boot.tv_sec;
}
DWORD get_dword_time()
{
struct timeval tv;
gettimeofday(&tv, NULL);
//tv.tv_sec -= 1057699978;
tv.tv_sec -= get_boot_sec();
return (tv.tv_sec * 1000 + tv.tv_usec / 1000);
}

152
libthecore/src/xdirent.c Normal file
View File

@ -0,0 +1,152 @@
#include "stdafx.h"
#ifdef __WIN32__
/*
Implementation of POSIX directory browsing functions and types for Win32.
Author: Kevlin Henney (kevlin@acm.org, kevlin@curbralan.com)
History: Created March 1997. Updated June 2003.
Rights: See end of file.
*/
#include "xdirent.h"
#include <errno.h>
#include <io.h> /* _findfirst and _findnext set errno iff they return -1 */
#include <stdlib.h>
#include <string.h>
#ifdef __cplusplus
extern "C"
{
#endif
struct DIR
{
long handle; /* -1 for failed rewind */
struct _finddata_t info;
struct dirent result; /* d_name null iff first time */
char *name; /* null-terminated char string */
};
DIR *opendir(const char *name)
{
DIR *dir = 0;
if(name && name[0])
{
size_t base_length = strlen(name);
const char *all = /* search pattern must end with suitable wildcard */
strchr("/\\", name[base_length - 1]) ? "*" : "/*";
if((dir = (DIR *) malloc(sizeof *dir)) != 0 &&
(dir->name = (char *) malloc(base_length + strlen(all) + 1)) != 0)
{
strcat(strcpy(dir->name, name), all);
if((dir->handle = (long) _findfirst(dir->name, &dir->info)) != -1)
{
dir->result.d_name = 0;
}
else /* rollback */
{
free(dir->name);
free(dir);
dir = 0;
}
}
else /* rollback */
{
free(dir);
dir = 0;
errno = ENOMEM;
}
}
else
{
errno = EINVAL;
}
return dir;
}
int closedir(DIR *dir)
{
int result = -1;
if(dir)
{
if(dir->handle != -1)
{
result = _findclose(dir->handle);
}
free(dir->name);
free(dir);
}
if(result == -1) /* map all errors to EBADF */
{
errno = EBADF;
}
return result;
}
struct dirent *readdir(DIR *dir)
{
struct dirent *result = 0;
if(dir && dir->handle != -1)
{
if(!dir->result.d_name || _findnext(dir->handle, &dir->info) != -1)
{
result = &dir->result;
result->d_name = dir->info.name;
}
}
else
{
errno = EBADF;
}
return result;
}
void rewinddir(DIR *dir)
{
if(dir && dir->handle != -1)
{
_findclose(dir->handle);
dir->handle = (long) _findfirst(dir->name, &dir->info);
dir->result.d_name = 0;
}
else
{
errno = EBADF;
}
}
#ifdef __cplusplus
}
#endif
/*
Copyright Kevlin Henney, 1997, 2003. All rights reserved.
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose is hereby granted without fee, provided
that this copyright and permissions notice appear in all copies and
derivatives.
This software is supplied "as is" without express or implied warranty.
But that said, if there are any problems please get in touch.
*/
#endif // #ifdef __WIN32__

228
libthecore/src/xgetopt.c Normal file
View File

@ -0,0 +1,228 @@
// XGetopt.cpp Version 1.2
//
// Author: Hans Dietrich
// hdietrich2@hotmail.com
//
// Description:
// XGetopt.cpp implements getopt(), a function to parse command lines.
//
// History
// Version 1.2 - 2003 May 17
// - Added Unicode support
//
// Version 1.1 - 2002 March 10
// - Added example to XGetopt.cpp module header
//
// This software is released into the public domain.
// You are free to use it in any way you like.
//
// This software is provided "as is" with no expressed
// or implied warranty. I accept no liability for any
// damage or loss of business that this software may cause.
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// if you are using precompiled headers then include this line:
#include "stdafx.h"
///////////////////////////////////////////////////////////////////////////////
#ifdef __WIN32__
///////////////////////////////////////////////////////////////////////////////
// if you are not using precompiled headers then include these lines:
//#include <windows.h>
//#include <stdio.h>
//#include <tchar.h>
///////////////////////////////////////////////////////////////////////////////
#include "xgetopt.h"
///////////////////////////////////////////////////////////////////////////////
//
// X G e t o p t . c p p
//
//
// NAME
// getopt -- parse command line options
//
// SYNOPSIS
// int getopt(int argc, TCHAR *argv[], TCHAR *optstring)
//
// extern TCHAR *optarg;
// extern int optind;
//
// DESCRIPTION
// The getopt() function parses the command line arguments. Its
// arguments argc and argv are the argument count and array as
// passed into the application on program invocation. In the case
// of Visual C++ programs, argc and argv are available via the
// variables __argc and __argv (double underscores), respectively.
// getopt returns the next option letter in argv that matches a
// letter in optstring. (Note: Unicode programs should use
// __targv instead of __argv. Also, all character and string
// literals should be enclosed in _T( ) ).
//
// optstring is a string of recognized option letters; if a letter
// is followed by a colon, the option is expected to have an argument
// that may or may not be separated from it by white space. optarg
// is set to point to the start of the option argument on return from
// getopt.
//
// Option letters may be combined, e.g., "-ab" is equivalent to
// "-a -b". Option letters are case sensitive.
//
// getopt places in the external variable optind the argv index
// of the next argument to be processed. optind is initialized
// to 0 before the first call to getopt.
//
// When all options have been processed (i.e., up to the first
// non-option argument), getopt returns EOF, optarg will point
// to the argument, and optind will be set to the argv index of
// the argument. If there are no non-option arguments, optarg
// will be set to NULL.
//
// The special option "--" may be used to delimit the end of the
// options; EOF will be returned, and "--" (and everything after it)
// will be skipped.
//
// RETURN VALUE
// For option letters contained in the string optstring, getopt
// will return the option letter. getopt returns a question mark (?)
// when it encounters an option letter not included in optstring.
// EOF is returned when processing is finished.
//
// BUGS
// 1) Long options are not supported.
// 2) The GNU double-colon extension is not supported.
// 3) The environment variable POSIXLY_CORRECT is not supported.
// 4) The + syntax is not supported.
// 5) The automatic permutation of arguments is not supported.
// 6) This implementation of getopt() returns EOF if an error is
// encountered, instead of -1 as the latest standard requires.
//
// EXAMPLE
// BOOL CMyApp::ProcessCommandLine(int argc, TCHAR *argv[])
// {
// int c;
//
// while ((c = getopt(argc, argv, _T("aBn:"))) != EOF)
// {
// switch (c)
// {
// case _T('a'):
// TRACE(_T("option a\n"));
// //
// // set some flag here
// //
// break;
//
// case _T('B'):
// TRACE( _T("option B\n"));
// //
// // set some other flag here
// //
// break;
//
// case _T('n'):
// TRACE(_T("option n: value=%d\n"), atoi(optarg));
// //
// // do something with value here
// //
// break;
//
// case _T('?'):
// TRACE(_T("ERROR: illegal option %s\n"), argv[optind-1]);
// return FALSE;
// break;
//
// default:
// TRACE(_T("WARNING: no handler for option %c\n"), c);
// return FALSE;
// break;
// }
// }
// //
// // check for non-option args here
// //
// return TRUE;
// }
//
///////////////////////////////////////////////////////////////////////////////
TCHAR *optarg; // global argument pointer
int optind = 0; // global argv index
int optreset = 0;
int getopt(int argc, TCHAR *argv[], TCHAR *optstring)
{
static TCHAR *next = NULL;
if (optreset != 0) {
optind = 0;
}
if (optind == 0)
next = NULL;
optarg = NULL;
if (next == NULL || *next == _T('\0'))
{
if (optind == 0)
optind++;
if (optind >= argc || argv[optind][0] != _T('-') || argv[optind][1] == _T('\0'))
{
optarg = NULL;
if (optind < argc)
optarg = argv[optind];
return EOF;
}
if (_tcscmp(argv[optind], _T("--")) == 0)
{
optind++;
optarg = NULL;
if (optind < argc)
optarg = argv[optind];
return EOF;
}
next = argv[optind];
next++; // skip past -
optind++;
}
TCHAR c = *next++;
TCHAR *cp = _tcschr(optstring, c);
if (cp == NULL || c == _T(':'))
return _T('?');
cp++;
if (*cp == _T(':'))
{
if (*next != _T('\0'))
{
optarg = next;
next = NULL;
}
else if (optind < argc)
{
optarg = argv[optind];
optind++;
}
else
{
return _T('?');
}
}
return c;
}
#endif // #ifdef __WIN32__

345
libthecore/src/xmd5.c Normal file
View File

@ -0,0 +1,345 @@
#include "stdafx.h"
#ifndef __FreeBSD__
/*
* luau (Lib Update/Auto-Update): Simple Update Library
* Copyright (C) 2003 David Eklund
*
* - This library is free software; you can redistribute it and/or -
* - modify it under the terms of the GNU Lesser General Public -
* - License as published by the Free Software Foundation; either -
* - version 2.1 of the License, or (at your option) any later version. -
* - -
* - This library is distributed in the hope that it will be useful, -
* - but WITHOUT ANY WARRANTY; without even the implied warranty of -
* - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -
* - Lesser General Public License for more details. -
* - -
* - You should have received a copy of the GNU Lesser General Public -
* - License along with this library; if not, write to the Free Software -
* - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -
*/
/*
* md5.h and md5.c are based off of md5hl.c, md5c.c, and md5.h from libmd, which in turn is
* based off the FreeBSD libmd library. Their respective copyright notices follow:
*/
/*
* This code implements the MD5 message-digest algorithm.
* The algorithm is due to Ron Rivest. This code was
* written by Colin Plumb in 1993, no copyright is claimed.
* This code is in the public domain; do with it what you wish.
*
* Equivalent code is available from RSA Data Security, Inc.
* This code has been tested against that, and is equivalent,
* except that you don't need to include two pages of legalese
* with every copy.
*/
/* ----------------------------------------------------------------------------
* "THE BEER-WARE LICENSE" (Revision 42):
* <phk@login.dkuug.dk> wrote this file. As long as you retain this notice you
* can do whatever you want with this stuff. If we meet some day, and you think
* this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
* ----------------------------------------------------------------------------
*
* $Id: md5.c,v 1.1.1.1 2004/04/02 05:11:38 deklund2 Exp $
*
*/
#include "xmd5.h"
#if __BYTE_ORDER == 1234
#define byteReverse(buf, len) /* Nothing */
#else
void byteReverse(unsigned char *buf, unsigned longs);
/*
* Note: this code is harmless on little-endian machines.
*/
void byteReverse(unsigned char *buf, unsigned longs)
{
uint32_t t;
do {
t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
((unsigned) buf[1] << 8 | buf[0]);
*(uint32_t *) buf = t;
buf += 4;
} while (--longs);
}
#endif /* ! __BYTE_ORDER == 1234 */
char *
lutil_md5_file (const char *filename, char *buf)
{
unsigned char buffer[BUFSIZ];
MD5_CTX ctx;
int f,i,j;
MD5Init(&ctx);
#ifndef __WIN32__
f = open(filename,O_RDONLY);
#else
f = _open(filename, _O_RDONLY);
#endif
if (f < 0) return 0;
while ((i = read(f,buffer,sizeof buffer)) > 0) {
MD5Update(&ctx,buffer,i);
}
j = errno;
close(f);
errno = j;
if (i < 0) return 0;
return MD5End(&ctx, buf);
}
char *
lutil_md5_data (const unsigned char *data, unsigned int len, char *buf)
{
MD5_CTX ctx;
MD5Init(&ctx);
MD5Update(&ctx,data,len);
return MD5End(&ctx, buf);
}
/* Non-Interface Methods */
/* from md5hl.c */
char *
MD5End(MD5_CTX *ctx, char *buf)
{
int i;
unsigned char digest[MD5_HASHBYTES];
static const char hex[]="0123456789abcdef";
if (!buf)
buf = (char*)malloc(33);
if (!buf)
return 0;
MD5Final(digest,ctx);
for (i=0;i<MD5_HASHBYTES;i++) {
buf[i+i] = hex[digest[i] >> 4];
buf[i+i+1] = hex[digest[i] & 0x0f];
}
buf[i+i] = '\0';
return buf;
}
/*
* Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
* initialization constants.
*/
void MD5Init(MD5_CTX *ctx)
{
ctx->buf[0] = 0x67452301;
ctx->buf[1] = 0xefcdab89;
ctx->buf[2] = 0x98badcfe;
ctx->buf[3] = 0x10325476;
ctx->bits[0] = 0;
ctx->bits[1] = 0;
}
/*
* Update context to reflect the concatenation of another buffer full
* of bytes.
*/
void MD5Update(MD5_CTX *ctx, unsigned char const *buf, unsigned len)
{
uint32_t t;
/* Update bitcount */
t = ctx->bits[0];
if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t)
ctx->bits[1]++; /* Carry from low to high */
ctx->bits[1] += len >> 29;
t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
/* Handle any leading odd-sized chunks */
if (t) {
unsigned char *p = (unsigned char *) ctx->in + t;
t = 64 - t;
if (len < t) {
memcpy(p, buf, len);
return;
}
memcpy(p, buf, t);
byteReverse(ctx->in, 16);
MD5Transform(ctx->buf, (uint32_t *) ctx->in);
buf += t;
len -= t;
}
/* Process data in 64-byte chunks */
while (len >= 64) {
memcpy(ctx->in, buf, 64);
byteReverse(ctx->in, 16);
MD5Transform(ctx->buf, (uint32_t *) ctx->in);
buf += 64;
len -= 64;
}
/* Handle any remaining bytes of data. */
memcpy(ctx->in, buf, len);
}
/*
* Final wrapup - pad to 64-byte boundary with the bit pattern
* 1 0* (64-bit count of bits processed, MSB-first)
*/
void MD5Final(unsigned char digest[16], MD5_CTX *ctx)
{
unsigned count;
unsigned char *p;
/* Compute number of bytes mod 64 */
count = (ctx->bits[0] >> 3) & 0x3F;
/* Set the first char of padding to 0x80. This is safe since there is
always at least one byte free */
p = ctx->in + count;
*p++ = 0x80;
/* Bytes of padding needed to make 64 bytes */
count = 64 - 1 - count;
/* Pad out to 56 mod 64 */
if (count < 8) {
/* Two lots of padding: Pad the first block to 64 bytes */
memset(p, 0, count);
byteReverse(ctx->in, 16);
MD5Transform(ctx->buf, (uint32_t *) ctx->in);
/* Now fill the next block with 56 bytes */
memset(ctx->in, 0, 56);
} else {
/* Pad block to 56 bytes */
memset(p, 0, count - 8);
}
byteReverse(ctx->in, 14);
/* Append length in bits and transform */
((uint32_t *) ctx->in)[14] = ctx->bits[0];
((uint32_t *) ctx->in)[15] = ctx->bits[1];
MD5Transform(ctx->buf, (uint32_t *) ctx->in);
byteReverse((unsigned char *) ctx->buf, 4);
memcpy(digest, ctx->buf, 16);
memset((char *) ctx, 0, sizeof(ctx)); /* In case it's sensitive */
}
/* The four core functions - F1 is optimized somewhat */
/* #define F1(x, y, z) (x & y | ~x & z) */
#define F1(x, y, z) (z ^ (x & (y ^ z)))
#define F2(x, y, z) F1(z, x, y)
#define F3(x, y, z) (x ^ y ^ z)
#define F4(x, y, z) (y ^ (x | ~z))
/* This is the central step in the MD5 algorithm. */
#define MD5STEP(f, w, x, y, z, data, s) \
( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
/*
* The core of the MD5 algorithm, this alters an existing MD5 hash to
* reflect the addition of 16 longwords of new data. MD5Update blocks
* the data and converts bytes into longwords for this routine.
*/
void MD5Transform(uint32_t buf[4], uint32_t const in[16])
{
register uint32_t a, b, c, d;
a = buf[0];
b = buf[1];
c = buf[2];
d = buf[3];
MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
buf[0] += a;
buf[1] += b;
buf[2] += c;
buf[3] += d;
}
#endif // #ifndef __FreeBSD__