mirror of
https://github.com/haiwen/ccnet-server.git
synced 2025-04-28 02:30:08 +00:00
333 lines
8.9 KiB
C
333 lines
8.9 KiB
C
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
|
|
#ifndef CCNET_UTILS_H
|
|
#define CCNET_UTILS_H
|
|
|
|
#include <sys/time.h>
|
|
#include <stdint.h>
|
|
#include <unistd.h>
|
|
#include <stdarg.h>
|
|
#include <glib.h>
|
|
#include <glib-object.h>
|
|
#include <stdlib.h>
|
|
|
|
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
|
|
#include <event2/util.h>
|
|
#else
|
|
#include <evutil.h>
|
|
#endif
|
|
|
|
#ifdef WIN32
|
|
#include <errno.h>
|
|
#include <glib/gstdio.h>
|
|
|
|
#ifndef WEXITSTATUS
|
|
#define WEXITSTATUS(status) (((status) & 0xff00) >> 8)
|
|
#endif
|
|
|
|
/* Borrowed from libevent */
|
|
#define ccnet_pipe_t intptr_t
|
|
|
|
int pgpipe (ccnet_pipe_t handles[2]);
|
|
#define ccnet_mkdir(a,b) g_mkdir((a),(b))
|
|
#define ccnet_pipe(a) pgpipe((a))
|
|
#define piperead(a,b,c) recv((a),(b),(c),0)
|
|
#define pipewrite(a,b,c) send((a),(b),(c),0)
|
|
#define pipeclose(a) closesocket((a))
|
|
|
|
static inline int ccnet_rename(const char *oldfile, const char *newfile)
|
|
{
|
|
int ret = g_rename (oldfile, newfile);
|
|
if (ret < 0) {
|
|
if (errno != EEXIST)
|
|
return -1;
|
|
|
|
ret = g_unlink(oldfile);
|
|
|
|
if (ret < 0) {
|
|
g_warning("ccnet_rename failed because g_unlink failed\n");
|
|
return -1;
|
|
}
|
|
return g_rename(oldfile, newfile);
|
|
}
|
|
return 0;
|
|
}
|
|
#else
|
|
|
|
#define ccnet_pipe_t int
|
|
|
|
#define ccnet_mkdir(a,b) g_mkdir((a),(b))
|
|
#define ccnet_pipe(a) pipe((a))
|
|
#define piperead(a,b,c) read((a),(b),(c))
|
|
#define pipewrite(a,b,c) write((a),(b),(c))
|
|
#define pipeclose(a) close((a))
|
|
#define ccnet_rename g_rename
|
|
#endif
|
|
|
|
#define pipereadn(a,b,c) recvn((a),(b),(c))
|
|
#define pipewriten(a,b,c) sendn((a),(b),(c))
|
|
|
|
#ifndef O_BINARY
|
|
#define O_BINARY 0
|
|
#endif
|
|
|
|
/* for debug */
|
|
#ifndef ccnet_warning
|
|
#define ccnet_warning(fmt, ...) g_warning("%s(%d): " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
|
|
#endif
|
|
|
|
#ifndef ccnet_error
|
|
#define ccnet_error(fmt, ...) g_error("%s(%d): " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
|
|
#endif
|
|
|
|
#ifndef ccnet_message
|
|
#define ccnet_message(fmt, ...) g_message("%s(%d): " fmt, __FILE__, __LINE__, ##__VA_ARGS__)
|
|
#endif
|
|
|
|
#define CCNET_DOMAIN g_quark_from_string("ccnet")
|
|
|
|
|
|
struct timeval timeval_from_msec (uint64_t milliseconds);
|
|
|
|
|
|
size_t ccnet_strlcpy (char *dst, const char *src, size_t size);
|
|
|
|
void rawdata_to_hex (const unsigned char *rawdata, char *hex_str, int n_bytes);
|
|
int hex_to_rawdata (const char *hex_str, unsigned char *rawdata, int n_bytes);
|
|
|
|
#define sha1_to_hex(sha1, hex) rawdata_to_hex((sha1), (hex), 20)
|
|
#define hex_to_sha1(hex, sha1) hex_to_rawdata((hex), (sha1), 20)
|
|
|
|
int calculate_sha1 (unsigned char *sha1, const char *msg);
|
|
int ccnet_sha1_equal (const void *v1, const void *v2);
|
|
unsigned int ccnet_sha1_hash (const void *v);
|
|
|
|
char* gen_uuid ();
|
|
void gen_uuid_inplace (char *buf);
|
|
gboolean is_uuid_valid (const char *uuid_str);
|
|
|
|
|
|
/* dir operations */
|
|
int checkdir (const char *dir);
|
|
int checkdir_with_mkdir (const char *path);
|
|
char* ccnet_expand_path (const char *src);
|
|
|
|
/**
|
|
* Make directory with 256 sub-directories from '00' to 'ff'.
|
|
* `base` and subdir will be created if they are not existing.
|
|
*/
|
|
int objstore_mkdir (const char *base);
|
|
void objstore_get_path (char *path, const char *base, const char *obj_id);
|
|
|
|
|
|
char** strsplit_by_space (char *string, int *length);
|
|
|
|
/* Read "n" bytes from a descriptor. */
|
|
ssize_t readn(int fd, void *vptr, size_t n);
|
|
ssize_t writen(int fd, const void *vptr, size_t n);
|
|
|
|
/* Read "n" bytes from a socket. */
|
|
ssize_t recvn(evutil_socket_t fd, void *vptr, size_t n);
|
|
ssize_t sendn(evutil_socket_t fd, const void *vptr, size_t n);
|
|
|
|
int copy_fd (int ifd, int ofd);
|
|
int copy_file (const char *dst, const char *src, int mode);
|
|
|
|
|
|
/* string utilities */
|
|
|
|
char** strsplit_by_char (char *string, int *length, char c);
|
|
|
|
char * strjoin_n (const char *seperator, int argc, char **argv);
|
|
|
|
int is_ipaddr_valid (const char *ip);
|
|
|
|
typedef void (*KeyValueFunc) (void *data, const char *key, char *value);
|
|
void parse_key_value_pairs (char *string, KeyValueFunc func, void *data);
|
|
|
|
typedef gboolean (*KeyValueFunc2) (void *data, const char *key,
|
|
const char *value);
|
|
void parse_key_value_pairs2 (char *string, KeyValueFunc2 func, void *data);
|
|
|
|
gchar* ccnet_key_file_get_string (GKeyFile *keyf,
|
|
const char *category,
|
|
const char *key);
|
|
|
|
|
|
GList *string_list_append (GList *str_list, const char *string);
|
|
GList *string_list_append_sorted (GList *str_list, const char *string);
|
|
GList *string_list_remove (GList *str_list, const char *string);
|
|
void string_list_free (GList *str_list);
|
|
gboolean string_list_is_exists (GList *str_list, const char *string);
|
|
void string_list_join (GList *str_list, GString *strbuf, const char *seperator);
|
|
GList *string_list_parse (const char *list_in_str, const char *seperator);
|
|
GList *string_list_parse_sorted (const char *list_in_str, const char *seperator);
|
|
gboolean string_list_sorted_is_equal (GList *list1, GList *list2);
|
|
|
|
char** ncopy_string_array (char **orig, int n);
|
|
void nfree_string_array (char **array, int n);
|
|
|
|
/* 64bit time */
|
|
gint64 get_current_time();
|
|
|
|
int
|
|
ccnet_generate_cipher (const char *passwd, int plen,
|
|
unsigned char *key, unsigned char *iv);
|
|
|
|
int
|
|
ccnet_encrypt_with_key (char **data_out,
|
|
int *out_len,
|
|
const char *data_in,
|
|
const int in_len,
|
|
const unsigned char *key,
|
|
const unsigned char *iv);
|
|
|
|
int
|
|
ccnet_decrypt_with_key (char **data_out,
|
|
int *out_len,
|
|
const char *data_in,
|
|
const int in_len,
|
|
const unsigned char *key,
|
|
const unsigned char *iv);
|
|
|
|
int
|
|
ccnet_encrypt (char **data_out,
|
|
int *out_len,
|
|
const char *data_in,
|
|
const int in_len,
|
|
const char *code,
|
|
const int code_len);
|
|
|
|
|
|
int
|
|
ccnet_decrypt (char **data_out,
|
|
int *out_len,
|
|
const char *data_in,
|
|
const int in_len,
|
|
const char *code,
|
|
const int code_len);
|
|
|
|
|
|
/*
|
|
* Utility functions for converting data to/from network byte order.
|
|
*/
|
|
|
|
static inline uint64_t
|
|
hton64(uint64_t val)
|
|
{
|
|
uint64_t ret;
|
|
uint8_t *ptr = (uint8_t *)&ret;
|
|
|
|
ptr[0]=((val)>>56)&0xFF;
|
|
ptr[1]=((val)>>48)&0xFF;
|
|
ptr[2]=((val)>>40)&0xFF;
|
|
ptr[3]=((val)>>32)&0xFF;
|
|
ptr[4]=((val)>>24)&0xFF;
|
|
ptr[5]=((val)>>16)&0xFF;
|
|
ptr[6]=((val)>>8)&0xFF;
|
|
ptr[7]=(val)&0xFF;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static inline uint64_t
|
|
ntoh64(uint64_t val)
|
|
{
|
|
uint64_t t64;
|
|
uint8_t *ptr = (uint8_t *)&val;
|
|
|
|
t64=(ptr[3]+256*(ptr[2]+256*(ptr[1]+256*ptr[0])));
|
|
t64<<=32;
|
|
t64|=((ptr[7]+256*(ptr[6]+256*(ptr[5]+256*ptr[4]))))&0xffffffffU;
|
|
|
|
return t64;
|
|
}
|
|
|
|
static inline void put64bit(uint8_t **ptr,uint64_t val) {
|
|
(*ptr)[0]=((val)>>56)&0xFF;
|
|
(*ptr)[1]=((val)>>48)&0xFF;
|
|
(*ptr)[2]=((val)>>40)&0xFF;
|
|
(*ptr)[3]=((val)>>32)&0xFF;
|
|
(*ptr)[4]=((val)>>24)&0xFF;
|
|
(*ptr)[5]=((val)>>16)&0xFF;
|
|
(*ptr)[6]=((val)>>8)&0xFF;
|
|
(*ptr)[7]=(val)&0xFF;
|
|
(*ptr)+=8;
|
|
}
|
|
|
|
static inline void put32bit(uint8_t **ptr,uint32_t val) {
|
|
(*ptr)[0]=((val)>>24)&0xFF;
|
|
(*ptr)[1]=((val)>>16)&0xFF;
|
|
(*ptr)[2]=((val)>>8)&0xFF;
|
|
(*ptr)[3]=(val)&0xFF;
|
|
(*ptr)+=4;
|
|
}
|
|
|
|
static inline void put16bit(uint8_t **ptr,uint16_t val) {
|
|
(*ptr)[0]=((val)>>8)&0xFF;
|
|
(*ptr)[1]=(val)&0xFF;
|
|
(*ptr)+=2;
|
|
}
|
|
|
|
static inline void put8bit(uint8_t **ptr,uint8_t val) {
|
|
(*ptr)[0]=(val)&0xFF;
|
|
(*ptr)++;
|
|
}
|
|
|
|
static inline uint64_t get64bit(const uint8_t **ptr) {
|
|
uint64_t t64;
|
|
t64=((*ptr)[3]+256*((*ptr)[2]+256*((*ptr)[1]+256*(*ptr)[0])));
|
|
t64<<=32;
|
|
t64|=(((*ptr)[7]+256*((*ptr)[6]+256*((*ptr)[5]+256*(*ptr)[4]))))&0xffffffffU;
|
|
(*ptr)+=8;
|
|
return t64;
|
|
}
|
|
|
|
static inline uint32_t get32bit(const uint8_t **ptr) {
|
|
uint32_t t32;
|
|
t32=((*ptr)[3]+256*((*ptr)[2]+256*((*ptr)[1]+256*(*ptr)[0])));
|
|
(*ptr)+=4;
|
|
return t32;
|
|
}
|
|
|
|
static inline uint16_t get16bit(const uint8_t **ptr) {
|
|
uint32_t t16;
|
|
t16=(*ptr)[1]+256*(*ptr)[0];
|
|
(*ptr)+=2;
|
|
return t16;
|
|
}
|
|
|
|
static inline uint8_t get8bit(const uint8_t **ptr) {
|
|
uint32_t t8;
|
|
t8=(*ptr)[0];
|
|
(*ptr)++;
|
|
return t8;
|
|
}
|
|
|
|
/* Convert between local encoding and utf8. Returns the converted
|
|
* string if success, otherwise return NULL
|
|
*/
|
|
char *ccnet_locale_from_utf8 (const gchar *src);
|
|
char *ccnet_locale_to_utf8 (const gchar *src);
|
|
|
|
/* Detect whether a process with the given name is running right now. */
|
|
gboolean process_is_running(const char *name);
|
|
|
|
#ifdef WIN32
|
|
int win32_kill_process (const char *process_name_in);
|
|
int win32_spawn_process (char *cmd, char *wd);
|
|
char *wchar_to_utf8 (const wchar_t *src);
|
|
wchar_t *wchar_from_utf8 (const char *src);
|
|
char **get_argv_utf8 (int *argc);
|
|
#endif
|
|
|
|
char* ccnet_object_type_from_id (const char *object_id);
|
|
|
|
gint64 ccnet_calc_directory_size (const char *path, GError **error);
|
|
|
|
#ifdef WIN32
|
|
char * strtok_r(char *s, const char *delim, char **save_ptr);
|
|
#endif
|
|
|
|
#endif
|