sad
/
udp2raw
mirror of https://github.com/wangyu-/udp2raw.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
udp2raw/common.cpp

1149 lines
30 KiB
C++
Raw Permalink Blame History

/*
* comm.cpp
*
* Created on: Jul 29, 2017
* Author: wangyu
*/
#include "common.h"
#include "log.h"
#include "misc.h"
#include <random>
#include <cmath>
// static int random_number_fd=-1;
int force_socket_buf = 0;
int address_t::from_str(char *str) {
clear();
char ip_addr_str[100];
u32_t port;
mylog(log_info, "parsing address: %s\n", str);
int is_ipv6 = 0;
if (sscanf(str, "[%[^]]]:%u", ip_addr_str, &port) == 2) {
mylog(log_info, "its an ipv6 adress\n");
inner.ipv6.sin6_family = AF_INET6;
is_ipv6 = 1;
} else if (sscanf(str, "%[^:]:%u", ip_addr_str, &port) == 2) {
mylog(log_info, "its an ipv4 adress\n");
inner.ipv4.sin_family = AF_INET;
} else {
mylog(log_error, "failed to parse\n");
myexit(-1);
}
mylog(log_info, "ip_address is {%s}, port is {%u}\n", ip_addr_str, port);
if (port > 65535) {
mylog(log_error, "invalid port: %d\n", port);
myexit(-1);
}
int ret = -100;
if (is_ipv6) {
ret = inet_pton(AF_INET6, ip_addr_str, &(inner.ipv6.sin6_addr));
inner.ipv6.sin6_port = htons(port);
if (ret == 0) // 0 if address type doesnt match
{
mylog(log_error, "ip_addr %s is not an ipv6 address, %d\n", ip_addr_str, ret);
myexit(-1);
} else if (ret == 1) // inet_pton returns 1 on success
{
// okay
} else {
mylog(log_error, "ip_addr %s is invalid, %d\n", ip_addr_str, ret);
myexit(-1);
}
} else {
ret = inet_pton(AF_INET, ip_addr_str, &(inner.ipv4.sin_addr));
inner.ipv4.sin_port = htons(port);
if (ret == 0) {
mylog(log_error, "ip_addr %s is not an ipv4 address, %d\n", ip_addr_str, ret);
myexit(-1);
} else if (ret == 1) {
// okay
} else {
mylog(log_error, "ip_addr %s is invalid, %d\n", ip_addr_str, ret);
myexit(-1);
}
}
return 0;
}
int address_t::from_str_ip_only(char *str) {
clear();
u32_t type;
if (strchr(str, ':') == NULL)
type = AF_INET;
else
type = AF_INET6;
((sockaddr *)&inner)->sa_family = type;
int ret;
if (type == AF_INET) {
ret = inet_pton(type, str, &inner.ipv4.sin_addr);
} else {
ret = inet_pton(type, str, &inner.ipv6.sin6_addr);
}
if (ret == 0) // 0 if address type doesnt match
{
mylog(log_error, "confusion in parsing %s, %d\n", str, ret);
myexit(-1);
} else if (ret == 1) // inet_pton returns 1 on success
{
// okay
} else {
mylog(log_error, "ip_addr %s is invalid, %d\n", str, ret);
myexit(-1);
}
return 0;
}
char *address_t::get_str() {
static char res[max_addr_len];
to_str(res);
return res;
}
void address_t::to_str(char *s) {
// static char res[max_addr_len];
char ip_addr[max_addr_len];
u32_t port;
const char *ret = 0;
if (get_type() == AF_INET6) {
ret = inet_ntop(AF_INET6, &inner.ipv6.sin6_addr, ip_addr, max_addr_len);
port = inner.ipv6.sin6_port;
} else if (get_type() == AF_INET) {
ret = inet_ntop(AF_INET, &inner.ipv4.sin_addr, ip_addr, max_addr_len);
port = inner.ipv4.sin_port;
} else {
assert(0 == 1);
}
if (ret == 0) // NULL on failure
{
mylog(log_error, "inet_ntop failed\n");
myexit(-1);
}
port = ntohs(port);
ip_addr[max_addr_len - 1] = 0;
if (get_type() == AF_INET6) {
sprintf(s, "[%s]:%u", ip_addr, (u32_t)port);
} else {
sprintf(s, "%s:%u", ip_addr, (u32_t)port);
}
// return res;
}
char *address_t::get_ip() {
char ip_addr[max_addr_len];
static char s[max_addr_len];
const char *ret = 0;
if (get_type() == AF_INET6) {
ret = inet_ntop(AF_INET6, &inner.ipv6.sin6_addr, ip_addr, max_addr_len);
} else if (get_type() == AF_INET) {
ret = inet_ntop(AF_INET, &inner.ipv4.sin_addr, ip_addr, max_addr_len);
} else {
assert(0 == 1);
}
if (ret == 0) // NULL on failure
{
mylog(log_error, "inet_ntop failed\n");
myexit(-1);
}
ip_addr[max_addr_len - 1] = 0;
if (get_type() == AF_INET6) {
sprintf(s, "%s", ip_addr);
} else {
sprintf(s, "%s", ip_addr);
}
return s;
}
int address_t::from_sockaddr(sockaddr *addr, socklen_t slen) {
clear();
// memset(&inner,0,sizeof(inner));
if (addr->sa_family == AF_INET6) {
assert(slen == sizeof(sockaddr_in6));
// inner.ipv6= *( (sockaddr_in6*) addr );
memcpy(&inner, addr, slen);
} else if (addr->sa_family == AF_INET) {
assert(slen == sizeof(sockaddr_in));
// inner.ipv4= *( (sockaddr_in*) addr );
memcpy(&inner, addr, slen);
} else {
assert(0 == 1);
}
return 0;
}
int address_t::new_connected_udp_fd() {
int new_udp_fd;
new_udp_fd = socket(get_type(), SOCK_DGRAM, IPPROTO_UDP);
if (new_udp_fd < 0) {
mylog(log_warn, "create udp_fd error\n");
return -1;
}
setnonblocking(new_udp_fd);
set_buf_size(new_udp_fd, socket_buf_size);
mylog(log_debug, "created new udp_fd %d\n", new_udp_fd);
int ret = connect(new_udp_fd, (struct sockaddr *)&inner, get_len());
if (ret != 0) {
mylog(log_warn, "udp fd connect fail %d %s\n", ret, strerror(errno));
// sock_close(new_udp_fd);
close(new_udp_fd);
return -1;
}
return new_udp_fd;
}
bool my_ip_t::equal(const my_ip_t &b) const {
// extern int raw_ip_version;
if (raw_ip_version == AF_INET) {
return v4 == b.v4;
} else if (raw_ip_version == AF_INET6) {
return memcmp(&v6, &b.v6, sizeof(v6)) == 0;
}
assert(0 == 1);
return 0;
}
char *my_ip_t::get_str1() const {
static char res[max_addr_len];
if (raw_ip_version == AF_INET6) {
assert(inet_ntop(AF_INET6, &v6, res, max_addr_len) != 0);
} else {
assert(raw_ip_version == AF_INET);
assert(inet_ntop(AF_INET, &v4, res, max_addr_len) != 0);
}
return res;
}
char *my_ip_t::get_str2() const {
static char res[max_addr_len];
if (raw_ip_version == AF_INET6) {
assert(inet_ntop(AF_INET6, &v6, res, max_addr_len) != 0);
} else {
assert(raw_ip_version == AF_INET);
assert(inet_ntop(AF_INET, &v4, res, max_addr_len) != 0);
}
return res;
}
int my_ip_t::from_address_t(address_t tmp_addr) {
if (tmp_addr.get_type() == raw_ip_version && raw_ip_version == AF_INET) {
v4 = tmp_addr.inner.ipv4.sin_addr.s_addr;
} else if (tmp_addr.get_type() == raw_ip_version && raw_ip_version == AF_INET6) {
v6 = tmp_addr.inner.ipv6.sin6_addr;
} else {
assert(0 == 1);
}
return 0;
}
/*
int my_ip_t::from_str(char * str)
{
u32_t type;
if(strchr(str,':')==NULL)
type=AF_INET;
else
type=AF_INET6;
int ret;
ret=inet_pton(type, str,this);
if(ret==0) // 0 if address type doesnt match
{
mylog(log_error,"confusion in parsing %s, %d\n",str,ret);
myexit(-1);
}
else if(ret==1) // inet_pton returns 1 on success
{
//okay
}
else
{
mylog(log_error,"ip_addr %s is invalid, %d\n",str,ret);
myexit(-1);
}
return 0;
}*/
#ifdef UDP2RAW_MP
int init_ws() {
#if defined(__MINGW32__)
WORD wVersionRequested;
WSADATA wsaData;
int err;
/* Use the MAKEWORD(lowbyte, highbyte) macro declared in Windef.h */
wVersionRequested = MAKEWORD(2, 2);
err = WSAStartup(wVersionRequested, &wsaData);
if (err != 0) {
/* Tell the user that we could not find a usable */
/* Winsock DLL. */
printf("WSAStartup failed with error: %d\n", err);
exit(-1);
}
/* Confirm that the WinSock DLL supports 2.2.*/
/* Note that if the DLL supports versions greater */
/* than 2.2 in addition to 2.2, it will still return */
/* 2.2 in wVersion since that is the version we */
/* requested. */
if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
/* Tell the user that we could not find a usable */
/* WinSock DLL. */
printf("Could not find a usable version of Winsock.dll\n");
WSACleanup();
exit(-1);
} else {
printf("The Winsock 2.2 dll was found okay");
}
int tmp[] = {0, 100, 200, 300, 500, 800, 1000, 2000, 3000, 4000, -1};
int succ = 0;
for (int i = 1; tmp[i] != -1; i++) {
if (_setmaxstdio(100) == -1)
break;
else
succ = i;
}
printf(", _setmaxstdio() was set to %d\n", tmp[succ]);
#endif
return 0;
}
#endif
#if defined(__MINGW32__)
int inet_pton(int af, const char *src, void *dst) {
struct sockaddr_storage ss;
int size = sizeof(ss);
char src_copy[max_addr_len + 1];
ZeroMemory(&ss, sizeof(ss));
/* stupid non-const API */
strncpy(src_copy, src, max_addr_len + 1);
src_copy[max_addr_len] = 0;
if (WSAStringToAddress(src_copy, af, NULL, (struct sockaddr *)&ss, &size) == 0) {
switch (af) {
case AF_INET:
*(struct in_addr *)dst = ((struct sockaddr_in *)&ss)->sin_addr;
return 1;
case AF_INET6:
*(struct in6_addr *)dst = ((struct sockaddr_in6 *)&ss)->sin6_addr;
return 1;
}
}
return 0;
}
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size) {
struct sockaddr_storage ss;
unsigned long s = size;
ZeroMemory(&ss, sizeof(ss));
ss.ss_family = af;
switch (af) {
case AF_INET:
((struct sockaddr_in *)&ss)->sin_addr = *(struct in_addr *)src;
break;
case AF_INET6:
((struct sockaddr_in6 *)&ss)->sin6_addr = *(struct in6_addr *)src;
break;
default:
return NULL;
}
/* cannot direclty use &size because of strict aliasing rules */
return (WSAAddressToString((struct sockaddr *)&ss, sizeof(ss), NULL, dst, &s) == 0) ? dst : NULL;
}
char *get_sock_error() {
static char buf[1000];
int e = WSAGetLastError();
wchar_t *s = NULL;
FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, e,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPWSTR)&s, 0, NULL);
sprintf(buf, "%d:%S", e, s);
int len = strlen(buf);
while (len > 0 && (buf[len - 1] == '\r' || buf[len - 1] == '\n')) {
len--;
buf[len] = 0;
}
LocalFree(s);
return buf;
}
int get_sock_errno() {
return WSAGetLastError();
}
#else
char *get_sock_error() {
static char buf[1000];
sprintf(buf, "%d:%s", errno, strerror(errno));
return buf;
}
int get_sock_errno() {
return errno;
}
#endif
u64_t get_current_time_us() {
static u64_t value_fix = 0;
static u64_t largest_value = 0;
u64_t raw_value = (u64_t)(ev_time() * 1000 * 1000);
u64_t fixed_value = raw_value + value_fix;
if (fixed_value < largest_value) {
value_fix += largest_value - fixed_value;
} else {
largest_value = fixed_value;
}
// printf("<%lld,%lld,%lld>\n",raw_value,value_fix,raw_value + value_fix);
return raw_value + value_fix; // new fixed value
}
u64_t get_current_time() {
return get_current_time_us() / 1000;
}
u64_t pack_u64(u32_t a, u32_t b) {
u64_t ret = a;
ret <<= 32u;
ret += b;
return ret;
}
u32_t get_u64_h(u64_t a) {
return a >> 32u;
}
u32_t get_u64_l(u64_t a) {
return (a << 32u) >> 32u;
}
char *my_ntoa(u32_t ip) {
in_addr a;
a.s_addr = ip;
return inet_ntoa(a);
}
/*
void init_random_number_fd()
{
random_number_fd=open("/dev/urandom",O_RDONLY);
if(random_number_fd==-1)
{
mylog(log_fatal,"error open /dev/urandom\n");
myexit(-1);
}
setnonblocking(random_number_fd);
}*/
#if !defined(__MINGW32__)
struct random_fd_t {
int random_number_fd;
random_fd_t() {
random_number_fd = open("/dev/urandom", O_RDONLY);
if (random_number_fd == -1) {
mylog(log_fatal, "error open /dev/urandom\n");
myexit(-1);
}
setnonblocking(random_number_fd);
}
int get_fd() {
return random_number_fd;
}
} random_fd;
#else
struct my_random_t {
std::random_device rd;
std::mt19937 gen;
std::uniform_int_distribution<u64_t> dis64;
std::uniform_int_distribution<u32_t> dis32;
std::uniform_int_distribution<unsigned char> dis8;
my_random_t() {
// std::mt19937 gen_tmp(rd()); //random device is broken on mingw
timespec tmp_time;
clock_gettime(CLOCK_MONOTONIC, &tmp_time);
long long a = ((u64_t)tmp_time.tv_sec) * 1000000000llu + ((u64_t)tmp_time.tv_nsec);
std::mt19937 gen_tmp(a);
gen = gen_tmp;
gen.discard(700000); // magic
}
u64_t gen64() {
return dis64(gen);
}
u32_t gen32() {
return dis32(gen);
}
unsigned char gen8() {
return dis8(gen);
}
/*int random_number_fd;
random_fd_t()
{
random_number_fd=open("/dev/urandom",O_RDONLY);
if(random_number_fd==-1)
{
mylog(log_fatal,"error open /dev/urandom\n");
myexit(-1);
}
setnonblocking(random_number_fd);
}
int get_fd()
{
return random_number_fd;
}*/
} my_random;
#endif
u64_t get_true_random_number_64() {
#if !defined(__MINGW32__)
u64_t ret;
int size = read(random_fd.get_fd(), &ret, sizeof(ret));
if (size != sizeof(ret)) {
mylog(log_fatal, "get random number failed %d\n", size);
myexit(-1);
}
return ret;
#else
return my_random.gen64(); // fake random number
#endif
}
u32_t get_true_random_number() {
#if !defined(__MINGW32__)
u32_t ret;
int size = read(random_fd.get_fd(), &ret, sizeof(ret));
if (size != sizeof(ret)) {
mylog(log_fatal, "get random number failed %d\n", size);
myexit(-1);
}
return ret;
#else
return my_random.gen32(); // fake random number
#endif
}
u32_t get_true_random_number_nz() // nz for non-zero
{
u32_t ret = 0;
while (ret == 0) {
ret = get_true_random_number();
}
return ret;
}
inline int is_big_endian() {
int i = 1;
return !*((char *)&i);
}
u64_t ntoh64(u64_t a) {
#ifdef UDP2RAW_LITTLE_ENDIAN
u32_t h = get_u64_h(a);
u32_t l = get_u64_l(a);
return pack_u64(ntohl(l), ntohl(h));
// return bswap_64( a);
#else
return a;
#endif
}
u64_t hton64(u64_t a) {
return ntoh64(a);
}
void write_u16(char *p, u16_t w) {
*(unsigned char *)(p + 1) = (w & 0xff);
*(unsigned char *)(p + 0) = (w >> 8);
}
u16_t read_u16(char *p) {
u16_t res;
res = *(const unsigned char *)(p + 0);
res = *(const unsigned char *)(p + 1) + (res << 8);
return res;
}
void write_u32(char *p, u32_t l) {
*(unsigned char *)(p + 3) = (unsigned char)((l >> 0) & 0xff);
*(unsigned char *)(p + 2) = (unsigned char)((l >> 8) & 0xff);
*(unsigned char *)(p + 1) = (unsigned char)((l >> 16) & 0xff);
*(unsigned char *)(p + 0) = (unsigned char)((l >> 24) & 0xff);
}
u32_t read_u32(char *p) {
u32_t res;
res = *(const unsigned char *)(p + 0);
res = *(const unsigned char *)(p + 1) + (res << 8);
res = *(const unsigned char *)(p + 2) + (res << 8);
res = *(const unsigned char *)(p + 3) + (res << 8);
return res;
}
void write_u64(char *s, u64_t a) {
assert(0 == 1);
}
u64_t read_u64(char *s) {
assert(0 == 1);
return 0;
}
void setnonblocking(int sock) {
#if !defined(__MINGW32__)
int opts;
opts = fcntl(sock, F_GETFL);
if (opts < 0) {
mylog(log_fatal, "fcntl(sock,GETFL)\n");
// perror("fcntl(sock,GETFL)");
myexit(1);
}
opts = opts | O_NONBLOCK;
if (fcntl(sock, F_SETFL, opts) < 0) {
mylog(log_fatal, "fcntl(sock,SETFL,opts)\n");
// perror("fcntl(sock,SETFL,opts)");
myexit(1);
}
#else
int iResult;
u_long iMode = 1;
iResult = ioctlsocket(sock, FIONBIO, &iMode);
if (iResult != NO_ERROR)
printf("ioctlsocket failed with error: %d\n", iResult);
#endif
}
/*
Generic checksum calculation function
*/
unsigned short csum(const unsigned short *ptr, int nbytes) { // works both for big and little endian
long sum;
unsigned short oddbyte;
short answer;
sum = 0;
while (nbytes > 1) {
sum += *ptr++;
nbytes -= 2;
}
if (nbytes == 1) {
oddbyte = 0;
*((u_char *)&oddbyte) = *(u_char *)ptr;
sum += oddbyte;
}
sum = (sum >> 16) + (sum & 0xffff);
sum = sum + (sum >> 16);
answer = (short)~sum;
return (answer);
}
unsigned short csum_with_header(char *header, int hlen, const unsigned short *ptr, int nbytes) { // works both for big and little endian
long sum;
unsigned short oddbyte;
short answer;
assert(hlen % 2 == 0);
sum = 0;
unsigned short *tmp = (unsigned short *)header;
for (int i = 0; i < hlen / 2; i++) {
sum += *tmp++;
}
while (nbytes > 1) {
sum += *ptr++;
nbytes -= 2;
}
if (nbytes == 1) {
oddbyte = 0;
*((u_char *)&oddbyte) = *(u_char *)ptr;
sum += oddbyte;
}
sum = (sum >> 16) + (sum & 0xffff);
sum = sum + (sum >> 16);
answer = (short)~sum;
return (answer);
}
int set_buf_size(int fd, int socket_buf_size) {
if (force_socket_buf) {
if (is_udp2raw_mp) {
mylog(log_fatal, "force_socket_buf not supported in this verion\n");
myexit(-1);
}
// assert(0==1);
#ifdef UDP2RAW_LINUX
if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &socket_buf_size, sizeof(socket_buf_size)) < 0) {
mylog(log_fatal, "SO_SNDBUFFORCE fail socket_buf_size=%d errno=%s\n", socket_buf_size, strerror(errno));
myexit(1);
}
if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &socket_buf_size, sizeof(socket_buf_size)) < 0) {
mylog(log_fatal, "SO_RCVBUFFORCE fail socket_buf_size=%d errno=%s\n", socket_buf_size, strerror(errno));
myexit(1);
}
#endif
} else {
if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &socket_buf_size, sizeof(socket_buf_size)) < 0) {
mylog(log_fatal, "SO_SNDBUF fail socket_buf_size=%d errno=%s\n", socket_buf_size, get_sock_error());
myexit(1);
}
if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &socket_buf_size, sizeof(socket_buf_size)) < 0) {
mylog(log_fatal, "SO_RCVBUF fail socket_buf_size=%d errno=%s\n", socket_buf_size, get_sock_error());
myexit(1);
}
}
return 0;
}
int numbers_to_char(my_id_t id1, my_id_t id2, my_id_t id3, char *&data, int &len) {
static char buf[buf_len];
data = buf;
my_id_t tmp = htonl(id1);
memcpy(buf, &tmp, sizeof(tmp));
tmp = htonl(id2);
memcpy(buf + sizeof(tmp), &tmp, sizeof(tmp));
tmp = htonl(id3);
memcpy(buf + sizeof(tmp) * 2, &tmp, sizeof(tmp));
len = sizeof(my_id_t) * 3;
return 0;
}
int char_to_numbers(const char *data, int len, my_id_t &id1, my_id_t &id2, my_id_t &id3) {
if (len < int(sizeof(my_id_t) * 3)) return -1;
// id1=ntohl( *((id_t*)(data+0)) );
memcpy(&id1, data + 0, sizeof(id1));
id1 = ntohl(id1);
// id2=ntohl( *((id_t*)(data+sizeof(id_t))) );
memcpy(&id2, data + sizeof(my_id_t), sizeof(id2));
id2 = ntohl(id2);
// id3=ntohl( *((id_t*)(data+sizeof(id_t)*2)) );
memcpy(&id3, data + sizeof(my_id_t) * 2, sizeof(id3));
id3 = ntohl(id3);
return 0;
}
int hex_to_u32(const string &a, u32_t &output) {
// string b="0x";
// b+=a;
if (sscanf(a.c_str(), "%x", &output) == 1) {
// printf("%s %x\n",a.c_str(),output);
return 0;
}
mylog(log_error, "<%s> doesnt contain a hex\n", a.c_str());
return -1;
}
int hex_to_u32_with_endian(const string &a, u32_t &output) {
// string b="0x";
// b+=a;
if (sscanf(a.c_str(), "%x", &output) == 1) {
output = htonl(output);
// printf("%s %x\n",a.c_str(),output);
return 0;
}
mylog(log_error, "<%s> doesnt contain a hex\n", a.c_str());
return -1;
}
bool larger_than_u32(u32_t a, u32_t b) {
return ((i32_t(a - b)) > 0);
/*
u32_t smaller,bigger;
smaller=min(a,b);//smaller in normal sense
bigger=max(a,b);
u32_t distance=min(bigger-smaller,smaller+(0xffffffff-bigger+1));
if(distance==bigger-smaller)
{
if(bigger==a)
{
return 1;
}
else
{
return 0;
}
}
else
{
if(smaller==b)
{
return 0;
}
else
{
return 1;
}
}
*/
}
bool larger_than_u16(uint16_t a, uint16_t b) {
return ((i16_t(a - b)) > 0);
/*
uint16_t smaller,bigger;
smaller=min(a,b);//smaller in normal sense
bigger=max(a,b);
uint16_t distance=min(bigger-smaller,smaller+(0xffff-bigger+1));
if(distance==bigger-smaller)
{
if(bigger==a)
{
return 1;
}
else
{
return 0;
}
}
else
{
if(smaller==b)
{
return 0;
}
else
{
return 1;
}
}*/
}
void myexit(int a) {
if (enable_log_color)
printf("%s\n", RESET);
#ifdef UDP2RAW_LINUX
if (keep_thread_running) {
if (pthread_cancel(keep_thread)) {
mylog(log_warn, "pthread_cancel failed\n");
} else {
mylog(log_info, "pthread_cancel success\n");
}
}
clear_iptables_rule();
#endif
exit(a);
}
vector<string> string_to_vec(const char *s, const char *sp) {
vector<string> res;
string str = s;
char *p = strtok((char *)str.c_str(), sp);
while (p != NULL) {
res.push_back(p);
// printf ("%s\n",p);
p = strtok(NULL, sp);
}
/* for(int i=0;i<(int)res.size();i++)
{
printf("<<%s>>\n",res[i].c_str());
}*/
return res;
}
vector<vector<string> > string_to_vec2(const char *s) {
vector<vector<string> > res;
vector<string> lines = string_to_vec(s, "\n");
for (int i = 0; i < int(lines.size()); i++) {
vector<string> tmp;
tmp = string_to_vec(lines[i].c_str(), "\t ");
res.push_back(tmp);
}
return res;
}
int read_file(const char *file, string &output) {
const int max_len = 3 * 1024 * 1024;
// static char buf[max_len+100];
string buf0;
buf0.reserve(max_len + 200);
char *buf = (char *)buf0.c_str();
buf[max_len] = 0;
// buf[sizeof(buf)-1]=0;
int fd = open(file, O_RDONLY);
if (fd == -1) {
mylog(log_error, "read_file %s fail\n", file);
return -1;
}
int len = read(fd, buf, max_len);
if (len == max_len) {
buf[0] = 0;
mylog(log_error, "%s too long,buf not large enough\n", file);
return -2;
} else if (len < 0) {
buf[0] = 0;
mylog(log_error, "%s read fail %d\n", file, len);
return -3;
} else {
buf[len] = 0;
output = buf;
}
return 0;
}
int run_command(string command0, char *&output, int flag) {
if (is_udp2raw_mp) {
mylog(log_fatal, "run_command not supported in this version\n");
myexit(-1);
}
#ifdef UDP2RAW_LINUX
FILE *in;
if ((flag & show_log) == 0) command0 += " 2>&1 ";
const char *command = command0.c_str();
int level = (flag & show_log) ? log_warn : log_debug;
if (flag & show_command) {
mylog(log_info, "run_command %s\n", command);
} else {
mylog(log_debug, "run_command %s\n", command);
}
static __thread char buf[1024 * 1024 + 100];
buf[sizeof(buf) - 1] = 0;
if (!(in = popen(command, "r"))) {
mylog(level, "command %s popen failed,errno %s\n", command, strerror(errno));
return -1;
}
int len = fread(buf, 1024 * 1024, 1, in);
if (len == 1024 * 1024) {
buf[0] = 0;
mylog(level, "too long,buf not larger enough\n");
return -2;
} else {
buf[len] = 0;
}
int ret;
if ((ret = ferror(in))) {
mylog(level, "command %s fread failed,ferror return value %d \n", command, ret);
return -3;
}
// if(output!=0)
output = buf;
ret = pclose(in);
int ret2 = WEXITSTATUS(ret);
if (ret != 0 || ret2 != 0) {
mylog(level, "commnad %s ,pclose returned %d ,WEXITSTATUS %d,errnor :%s \n", command, ret, ret2, strerror(errno));
return -4;
}
#endif
return 0;
}
/*
int run_command_no_log(string command0,char * &output) {
FILE *in;
command0+=" 2>&1 ";
const char * command=command0.c_str();
mylog(log_debug,"run_command_no_log %s\n",command);
static char buf[1024*1024+100];
buf[sizeof(buf)-1]=0;
if(!(in = popen(command, "r"))){
mylog(log_debug,"command %s popen failed,errno %s\n",command,strerror(errno));
return -1;
}
int len =fread(buf, 1024*1024, 1, in);
if(len==1024*1024)
{
buf[0]=0;
mylog(log_debug,"too long,buf not larger enough\n");
return -2;
}
else
{
buf[len]=0;
}
int ret;
if(( ret=ferror(in) ))
{
mylog(log_debug,"command %s fread failed,ferror return value %d \n",command,ret);
return -3;
}
//if(output!=0)
output=buf;
ret= pclose(in);
int ret2=WEXITSTATUS(ret);
if(ret!=0||ret2!=0)
{
mylog(log_debug,"commnad %s ,pclose returned %d ,WEXITSTATUS %d,errnor :%s \n",command,ret,ret2,strerror(errno));
return -4;
}
return 0;
}*/
// Remove preceding and trailing characters
string trim(const string &str, char c) {
size_t first = str.find_first_not_of(c);
if (string::npos == first) {
return "";
}
size_t last = str.find_last_not_of(c);
return str.substr(first, (last - first + 1));
}
vector<string> parse_conf_line(const string &s0) {
string s = s0;
s.reserve(s.length() + 200);
char *buf = (char *)s.c_str();
// char buf[s.length()+200];
char *p = buf;
int i = int(s.length()) - 1;
int j;
vector<string> res;
// strcpy(buf,(char *)s.c_str());
while (i >= 0) {
if (buf[i] == ' ' || buf[i] == '\t')
buf[i] = 0;
else
break;
i--;
}
while (*p != 0) {
if (*p == ' ' || *p == '\t') {
p++;
} else
break;
}
int new_len = strlen(p);
if (new_len == 0) return res;
if (p[0] == '#') return res;
if (p[0] != '-') {
mylog(log_fatal, "line :<%s> not begin with '-' ", s.c_str());
myexit(-1);
}
for (i = 0; i < new_len; i++) {
if (p[i] == ' ' || p[i] == '\t') {
break;
}
}
if (i == new_len) {
res.push_back(p);
return res;
}
j = i;
while (p[j] == ' ' || p[j] == '\t')
j++;
p[i] = 0;
res.push_back(p);
res.push_back(p + j);
return res;
}
int create_fifo(char *file) {
#if !defined(__MINGW32__)
if (mkfifo(file, 0666) != 0) {
if (errno == EEXIST) {
mylog(log_warn, "warning fifo file %s exist\n", file);
} else {
mylog(log_fatal, "create fifo file %s failed\n", file);
myexit(-1);
}
}
int fifo_fd = open(file, O_RDWR);
if (fifo_fd < 0) {
mylog(log_fatal, "create fifo file %s failed\n", file);
myexit(-1);
}
struct stat st;
if (fstat(fifo_fd, &st) != 0) {
mylog(log_fatal, "fstat failed for fifo file %s\n", file);
myexit(-1);
}
if (!S_ISFIFO(st.st_mode)) {
mylog(log_fatal, "%s is not a fifo\n", file);
myexit(-1);
}
setnonblocking(fifo_fd);
return fifo_fd;
#else
mylog(log_fatal, "--fifo not supported in this version\n");
myexit(-1);
return 0;
#endif
}
/*
void ip_port_t::from_u64(u64_t u64)
{
ip=get_u64_h(u64);
port=get_u64_l(u64);
}
u64_t ip_port_t::to_u64()
{
return pack_u64(ip,port);
}
char * ip_port_t::to_s()
{
static char res[40];
sprintf(res,"%s:%d",my_ntoa(ip),port);
return res;
}*/
void print_binary_chars(const char *a, int len) {
for (int i = 0; i < len; i++) {
unsigned char b = a[i];
log_bare(log_debug, "<%02x>", (int)b);
}
log_bare(log_debug, "\n");
}
u32_t djb2(unsigned char *str, int len) {
u32_t hash = 5381;
int c;
for (int i=0; i<len ;i++) {
c = *(str++);
hash = ((hash << 5) + hash) ^ c; /* (hash * 33) ^ c */
}
hash = htonl(hash);
return hash;
}
u32_t sdbm(unsigned char *str, int len) {
u32_t hash = 0;
int c;
for (int i=0; i<len ;i++) {
c = *(str++);
hash = c + (hash << 6) + (hash << 16) - hash;
}
// hash=htonl(hash);
return hash;
}
Reference in New Issue View Git Blame Copy Permalink