atmos
/
ban2fail
дзеркало https://github.com/jrbrtsn/ban2fail
1
1
Форк 0
Код Задачі Релізи Вікі Активність
ban2fail/util.c

982 рядки
24 KiB
C
Неформатований Постійне посилання Звинувачення Історія

/***************************************************************************
* Copyright (C) 2018 by John D. Robertson *
* john@rrci.com *
* *
* This program 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 3 of the License, or *
* (at your option) any later version. *
* *
* This program 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 *
* *
* 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. *
***************************************************************************/
/***************************************************************************
util.h - description
Common utility routines needed by most c and c++ applications.
-------------------
begin : Fri Oct 19 10:09:38 EDT 2018
email : john@rrci.com
***************************************************************************/
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <math.h>
#include <netdb.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
#include <sys/poll.h>
#include <sys/socket.h>
#include <sys/types.h>
#include "ez_libc.h"
#include "util.h"
#define MSGBUF_SZ 4096
static void
dflt_eprintf_line (const char *fmt, va_list ap)
/***************************************************************
* default line vprintf()'ing function for eprintf() and friends.
*/
{
vfprintf(stderr, fmt, ap);
fputc ('\n', stderr);
fflush (stderr);
}
/* Static data for all threads */
static struct {
eprintf_line_f prt_f;
} S = {
.prt_f= dflt_eprintf_line
};
eprintf_line_f
set_eprintf_line (eprintf_line_f newFunc)
/****************************************************
* Set the global eprintf line vprintf()'ing function.
*/
{
eprintf_line_f rtn= S.prt_f;
S.prt_f= newFunc;
return rtn;
}
/* Function to print out an error message. Usualy called by eprintf() macro. */
void _eprintf(
#ifdef DEBUG
const char* filename,
int lineno,
const char *func,
#endif
const char *fmt,
...
)
/*********************************************************************************
* Function to simplify printing error messages.
*/
{
va_list args;
char buf[MSGBUF_SZ];
#ifdef DEBUG
/* Put the filename, lineno, and function name into a new format string */
snprintf(buf, MSGBUF_SZ-1, "%s line %d, %s(): %s", filename, lineno, func, fmt);
#else
snprintf(buf, MSGBUF_SZ-1, "%s", fmt);
#endif
/* make sure buffer is null terminated */
buf[MSGBUF_SZ-1]= '\0';
/* Pass on doctored format string and varargs to vfprintf() */
va_start(args, fmt);
(* S.prt_f) (buf, args);
va_end(args);
}
/* Function to print out an error message. Usualy called by sys_eprintf() macro. */
void _sys_eprintf(
const char* (*strerror_f)(int errnum),
#ifdef DEBUG
const char* filename,
int lineno,
const char *func,
#endif
const char *fmt,
...
)
/*********************************************************************************
* Function to simplify printing error messages.
*/
{
va_list args;
char buf[MSGBUF_SZ];
/* Put the filename, lineno, and function name into a new format string */
#ifdef DEBUG
snprintf(buf, MSGBUF_SZ-1, "%s line %d, %s(): %s [ %s ]", filename, lineno, func, fmt, (*strerror_f)(errno));
#else
snprintf(buf, MSGBUF_SZ-1, "%s [ %s ]", fmt, (*strerror_f)(errno));
#endif
/* make sure buffer is null terminated */
buf[MSGBUF_SZ-1]= '\0';
/* Pass on doctored format string and varargs to vfprintf() */
va_start(args, fmt);
(* S.prt_f) (buf, args);
va_end(args);
}
int64_t
timespec2ms(const struct timespec *ts)
/**********************************************************************
* Convert a timespec structure to integer milliseconds.
*/
{
return ts->tv_sec*1000 + ts->tv_nsec/1000000;
}
struct timespec*
ms2timespec(struct timespec *rtnBuf, int64_t ms)
/**********************************************************************
* Load up a timespec struct given number of milliseconds.
*/
{
rtnBuf->tv_sec= ms/1000;
rtnBuf->tv_nsec= (ms%1000)*1000000;
return rtnBuf;
}
const char*
bits2str(int64_t bits, const struct bitTuple *btArr)
/**********************************************************************
* Returns a null terminated buffer with OR'd set bits
* printed out.
*/
{
/* Rotating buffers so this can be used multiple times as arg to printf() */
#define N_BUFS 10
static _Thread_local char bufArr[N_BUFS][1024];
static _Thread_local unsigned count;
const struct bitTuple *t;
unsigned offset;
char *buf= bufArr[++count%N_BUFS];
/* Need this in case no bits are set */
buf[0]= '\0';
for(offset= 0, t= btArr; t->name; ++t) {
if(!(bits & t->bit)) continue;
if(offset) offset += sprintf(buf+offset, "|");
offset += sprintf(buf+offset, "%s", t->name);
}
return buf;
#undef N_BUFS
}
static const struct bitTuple*
findBitTuple(const char *symbol, const struct bitTuple *btArr)
/**********************************************************************
* brute force search for matching symbol.
*/
{
const struct bitTuple *bt;
for(bt= btArr; bt->name; ++bt) {
if(!strcmp(symbol, bt->name)) return bt;
}
return NULL;
}
int
str2bits(int64_t *rtnBuf, const char *str, const struct bitTuple *btArr)
/**********************************************************************
* Convert all OR'd symbolic bits in str into the return value.
*
* RETURNS: 0 for success, -1 for error.
*/
{
*rtnBuf= 0;
if(!strlen(str)) return 0;
int rtn= -1;
char symbolArr[20][60];
memset(symbolArr, 0, sizeof(symbolArr));
int rc= sscanf(str,
"%59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
"| %59[^|] "
,symbolArr[0]
,symbolArr[1]
,symbolArr[2]
,symbolArr[3]
,symbolArr[4]
,symbolArr[5]
,symbolArr[6]
,symbolArr[7]
,symbolArr[8]
,symbolArr[9]
,symbolArr[10]
,symbolArr[11]
,symbolArr[12]
,symbolArr[13]
,symbolArr[14]
,symbolArr[15]
,symbolArr[16]
,symbolArr[17]
,symbolArr[18]
,symbolArr[19]
);
if(-1 == rc) {
sys_eprintf("ERROR: sscanf() failed");
goto abort;
}
for(int i= 0; i < rc; ++i) {
const struct bitTuple *bt= findBitTuple(symbolArr[i], btArr);
if(!bt) {
eprintf("ERROR: \"%s\" not found in bitTuple array.", symbolArr[i]);
goto abort;
}
*rtnBuf |= bt->bit;
}
rtn= 0;
abort:
return rtn;
}
void
printBuffer(FILE *fh, const char *buf)
/************************************************************************************
* Print out the supplied buffer, replacing unprintable characters with the corresponding
* hex value in pointy brackets, e.g. <0x01>
*/
{
const char *pc;
/* Print something for each character */
for(pc= buf; pc && *pc; ++pc) {
if(isprint(*pc)) { /* Character is printable */
fputc(*pc, fh);
} else { /* Character is NOT printable, show hex number instead */
fprintf(fh, "<0x%02X>", *pc);
}
}
}
int64_t
clock_gettime_ms(clockid_t whichClock)
/**********************************************************************
* Returns current value of whichClock in milliseconds, avoiding the
* need for struct timespec.
* See man clock_gettime for more information.
*/
{
struct timespec ts;
if(-1 == clock_gettime(whichClock, &ts)) {
sys_eprintf("\tclock_gettime() failed");
abort();
}
return timespec2ms(&ts);
}
const char*
local_strftime (const time_t *pWhen, const char *fmt)
/***************************************************
* Get local time in a static string buffer
*/
{
/* Rotating buffers so this can be used multiple times as arg to printf() */
#define N_BUFS 5
#define BUF_SZ 64
static _Thread_local char bufArr[N_BUFS][BUF_SZ];
static _Thread_local unsigned count;
char *buf= bufArr[++count%N_BUFS];
/* Print the local time to a buffer */
struct tm *tm= localtime (pWhen);
if (!tm) {
sys_eprintf ("localtime() failed");
return NULL;
}
if (!strftime (buf, BUF_SZ-1, fmt, tm)) {
sys_eprintf ("strftime(\"%s\") failed", fmt);
return NULL;
}
return buf;
#undef BUF_SZ
#undef N_BUFS
}
const char*
strbits(int64_t bits, unsigned nBytes)
/**********************************************************************
* Convert a bits to a null terminated string of '1' and '0' characters.
* Uses rotating per-thread static buffer for return, so it is safe
* to call multiple times in a single printf()ish invocation.
*
* bits: bit field of interest.
* nBytes: Number of bytes to consider.
*
* RETURNS:
* null terminated buffer with a string representing bits as '0' or '1'
*/
{
/* Rotating buffers so this can be used multiple times as arg to printf() */
#define N_BUFS 8
#define BUF_SZ 65
static _Thread_local char bufArr[N_BUFS][BUF_SZ];
static _Thread_local unsigned count;
char *buf= bufArr[++count%N_BUFS];
unsigned pos= 0;
/* order bits from MSbit -> LSbit */
for(unsigned n= nBytes; n--;) {
unsigned char byte= (bits >>(8*n)) << 56 >> 56;
for(unsigned bit= 7; bit--;) {
buf[pos]= byte & 1<<bit ? '1' : '0';
++pos;
}
}
buf[pos]= '\0';
return buf;
#undef BUF_SZ
#undef N_BUFS
}
int
fd_setNONBLOCK (int fd)
/***************************************************
* Set a file descriptor to non-blocking mode.
*/
{
int rtn= -1;
/* Set for non-blocking I/O */
int fcntlFlgs;
/* This sets 'status' flags */
if((fcntlFlgs= fcntl(fd, F_GETFL)) == -1 ||
fcntl(fd, F_SETFL, fcntlFlgs | O_NONBLOCK) == -1 ||
(fcntlFlgs= fcntl(fd, F_GETFD)) == -1 ||
fcntl(fd, F_SETFD, fcntlFlgs | FD_CLOEXEC) == -1) {
sys_eprintf("fcntl() failed");
abort();
}
/* This sets 'descriptor' flags */
fcntlFlgs= fcntl(fd, F_GETFD);
if(fcntl(fd, F_SETFD, fcntlFlgs | FD_CLOEXEC) < 0) {
sys_eprintf("fcntl() failed");
abort();
}
rtn= 0;
abort:
return rtn;
}
const struct enumTuple*
str2enum(const char *str, const struct enumTuple *etArr)
/**********************************************************************
* Try to match str with an entry in the enumTupeArr.
*/
{
const struct enumTuple *et;
for(et= etArr; et->name; ++et) {
if(!strcmp(str, et->name)) return et;
}
return NULL;
}
const char*
enum2str(int enumVal, const struct enumTuple *etArr)
/**********************************************************************
* Return a the string representing enumVal, or NULL.
*/
{
const struct enumTuple *et;
for(et= etArr; et->name; ++et) {
if(enumVal == et->enumVal) return et->name;
}
return NULL;
}
int
sleep_ms(unsigned msec)
/***************************************************
* Sleep for the specified number of milliseconds.
*/
{
struct timespec ts;
ts.tv_sec= msec/1000;
ts.tv_nsec= (msec%1000)*1000000;
return nanosleep(&ts, NULL);
}
int
tcp_connect(const char *hostName, unsigned short port)
/***************************************************
* Blocking TCP connect for convenience.
*/
{
int rtn= -1, sock;
struct hostent *hp;
struct sockaddr_in sin;
sock = socket(AF_INET, SOCK_STREAM, 0);
if(-1 == sock) {
sys_eprintf("ERROR: socket() failed.");
goto abort;
}
// Initialize socket address structure
hp = gethostbyname(hostName);
if(!hp) {
sys_eprintf("ERROR: gethostbyname(\"%s\") failed.", hostName);
goto abort;
}
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
memcpy(&(sin.sin_addr.s_addr), hp->h_addr, hp->h_length);
int err= connect(sock, (struct sockaddr *)&sin, sizeof(sin));
if(-1 == err) {
sys_eprintf("ERROR: connect(%s:%hu) failed.", hostName, port);
goto abort;
}
rtn= sock;
abort:
if(-1 == rtn) {
if(-1 != sock) {
ez_close(sock);
}
}
return rtn;
}
int
tm_normalize(struct tm *buf)
/***************************************************
* Normalize buf so member values are corrected.
* Returns 0 for success, -1 for failure.
*/
{
buf->tm_isdst= -1;
time_t tt= mktime(buf);
if(!localtime_r(&tt, buf)) {
sys_eprintf ("localtime() failed");
return -1;
}
return 0;
}
int
secs2tod(const time_t *pFrom, int tod_sec)
/***************************************************
* Return the smallest number of seconds in the future
* remaining between from and tod_sec time-of-day, without
* respect to which day of the week/month/year.
*/
{
assert(0 <= tod_sec && (23*3600+59*60+59) >= tod_sec);
if(0 > tod_sec || (23*3600+59*60+59) < tod_sec) return -1;
/* Get the local time breakdown in a buffer */
struct tm tm_from;
if(!localtime_r(pFrom, &tm_from)) {
sys_eprintf ("localtime_r() failed");
abort();
}
/* We'll look at today and tomorrow */
for(int day= 0; day <= 1; ++day) {
struct tm tm= tm_from;
tm.tm_mday += day;
if(-1 == tm_normalize(&tm)) assert(0);
tm.tm_hour= tod_sec / 3600;
tm.tm_min= (tod_sec % 3600) / 60;
tm.tm_sec= (tod_sec % 3600) % 60;
time_t dptime= timelocal(&tm);
if(dptime > *pFrom) return (int)(dptime - *pFrom);
}
assert(0);
/* Can't find a time (should be impossible to get here) */
return -1;
}
const char*
indentStr(unsigned lvl, const char *pfix)
/***************************************************
* Return a string with lvl concatenated pfix strings.
*/
{
#define N_BUFS 10
#define BUF_SZ 128
static _Thread_local char bufArr[N_BUFS][BUF_SZ];
static _Thread_local unsigned count;
char *buf= bufArr[++count%N_BUFS];
size_t len= strlen(pfix);
buf[0]= '\0';
for(unsigned i= 0; (i+1)*len < BUF_SZ && i < lvl; ++i) {
strncpy(buf+i*len, pfix, len+1);
}
return buf;
#undef BUF_SZ
#undef N_BUFS
}
int
regex_compile(regex_t *preg, const char *pattern, int cflags)
/***************************************************
* Regular expression compile with error reporting.
*/
{
int rc, rtn= -1;
rc= regcomp(preg, pattern, cflags);
if(rc) {
#define BUF_SZ 1024
char buf[BUF_SZ];
regerror(rc, preg, buf, BUF_SZ);
eprintf("ERROR: %s", buf);
goto abort;
#undef BUF_SZ
}
rtn= 0;
abort:
return rtn;
}
FILE*
pager_open(void)
/***************************************************
* popen() the caller's pager.
*/
{
char *cmd= getenv("PAGER");
if(!cmd)
cmd= "/bin/more";
return ez_popen(cmd, "w");
}
const char*
prefix_home(const char *fname)
/***************************************************
* return $HOME/fname in a static buffer.
*/
{
#define N_BUFS 4
#define BUF_SZ PATH_MAX+1
static _Thread_local char bufArr[N_BUFS][BUF_SZ];
static _Thread_local unsigned count;
char *buf = bufArr[++count % N_BUFS];
const char *home_env= getenv("HOME");
if(home_env) {
snprintf(buf, BUF_SZ-1, "%s/%s", home_env, fname);
} else {
snprintf(buf, BUF_SZ-1, "%s", fname);
}
return buf;
#undef BUF_SZ
#undef N_BUFS
}
const char*
pthread_t_str(pthread_t tid)
/***************************************************
* return a hexidecimal representation of tid in
* a rotating static buffer.
*/
{
#define N_BUFS 10
#define BUF_SZ (sizeof(tid)*2+3)
static _Thread_local char bufArr[N_BUFS][BUF_SZ];
static _Thread_local unsigned count;
char *buf = bufArr[++count % N_BUFS];
strcpy(buf, "0x");
char *dst= buf+2;
unsigned i, byte;
size_t sz= sizeof(tid);
for(i= 0; i < sz; ++i) {
byte= *((unsigned char *)(&tid) + sz - i - 1);
dst += sprintf(dst, "%02x", byte);
}
*dst= '\0';
return buf;
#undef BUF_SZ
#undef N_BUFS
}
char*
skipspace(char *str)
/***************************************************
* return first character in str which is not
* whitespace, which could be the terminating null.
*/
{
for(; *str && isspace(*str); ++str);
return str;
}
const char*
skipspacec(const char *str)
/***************************************************
* return first character in str which is not
* whitespace, which could be the terminating null.
*/
{
for(; *str && isspace(*str); ++str);
return str;
}
char*
trimend(char *str)
/***************************************************
* Trim space on end of string by replacing it with
* null bytes.
*/
{
size_t len= strlen(str);
for(; len && isspace(str[len-1]); str[--len]= '\0');
return str;
}
void
julian_2_gregorian(int *year, int *month, int *day, uint32_t julianDay)
/************************************************************************
* Gregorian calendar starting from October 15, 1582
* This algorithm is from Henry F. Fliegel and Thomas C. Van Flandern
*/
{
uint64_t ell, n, i, j;
ell = (uint64_t)julianDay + 68569;
n = (4 * ell) / 146097;
ell = ell - (146097 * n + 3) / 4;
i = (4000 * (ell + 1)) / 1461001;
ell = ell - (1461 * i) / 4 + 31;
j = (80 * ell) / 2447;
*day = ell - (2447 * j) / 80;
ell = j / 11;
*month = j + 2 - (12 * ell);
*year = 100 * (n - 49) + i + ell;
}
int32_t
gregorian_2_julian(int year, int month, int day)
/* Gregorian calendar starting from October 15, 1582
* Algorithm from Henry F. Fliegel and Thomas C. Van Flandern
*/
{
return (1461 * (year + 4800 + (month - 14) / 12)) / 4
+ (367 * (month - 2 - 12 * ((month - 14) / 12))) / 12
- (3 * ((year + 4900 + (month - 14) / 12) / 100)) / 4
+ day - 32075;
}
const char*
bytes_2_hexStr(
char *rtn_sbuf,
unsigned rtn_sz,
const unsigned char *src,
unsigned src_len
)
/***************************************************************
* Convert bytes to hex characters, place in rtn_sbuf.
*/
{
if(src_len*2 >= rtn_sz)
return NULL;
unsigned i;
for(i= 0; i < src_len; ++i) {
snprintf(rtn_sbuf+i*2, rtn_sz-i*2, "%02x", (int)src[i]);
}
/* Null terminate the result */
rtn_sbuf[i*2]= '\0';
return rtn_sbuf;
}
int
rmdir_recursive(const char *path)
/***************************************************************
* recursively remove a directory and all of it's contents.
* RETURNS:
* 0 for success
* -1 for error
*/
{
int rtn= -1;
struct stat st;
DIR *dir= ez_opendir(path);
struct dirent *entry;
STR sb;
STR_constructor(&sb, PATH_MAX);
while((entry= ez_readdir(dir))) {
/* Skip uninteresting entries */
if(!strcmp(".", entry->d_name) ||
!strcmp("..", entry->d_name)) continue;
STR_reset(&sb);
STR_sprintf(&sb, "%s/%s", path, entry->d_name);
ez_stat(STR_str(&sb), &st);
if (S_ISDIR(st.st_mode)) {
int rc= rmdir_recursive(STR_str(&sb));
if(rc)
goto abort;
} else {
ez_unlink(STR_str(&sb));
}
}
rtn= 0;
abort:
if(!rtn)
ez_rmdir(path);
STR_destructor(&sb);
return rtn;
}
int _ez_rmdir_recursive (
const char *fileName,
int lineNo,
const char *funcName,
const char *pathname
)
/***************************************************************
* ez version of rmdir_recursive().
*/
{
int rtn= rmdir_recursive (pathname);
if (-1 == rtn) {
_eprintf(fileName, lineNo, funcName, "rmdir_recursive(\"%s\") failed", pathname);
abort();
}
return rtn;
}
/*============================================================*/
/*================ struct addrinfo ===========================*/
/*============================================================*/
const static struct bitTuple ai_flags_btArr[]= {
{.name= "AI_ADDRCONFIG", .bit= AI_ADDRCONFIG},
{.name= "AI_ALL", .bit= AI_ALL},
{.name= "AI_CANONNAME", .bit= AI_CANONNAME},
{.name= "AI_NUMERICHOST", .bit= AI_NUMERICHOST},
{.name= "AI_NUMERICSERV", .bit= AI_NUMERICSERV},
{.name= "AI_PASSIVE", .bit= AI_PASSIVE},
{.name= "AI_V4MAPPED", .bit= AI_V4MAPPED},
{}
};
const static struct enumTuple ai_family_etArr[]= {
{.name= "AF_INET", .enumVal= AF_INET},
{.name= "AF_INET6", .enumVal= AF_INET6},
{.name= "AF_UNSPEC", .enumVal= AF_UNSPEC},
{}
};
const static struct enumTuple ai_socktype_etArr[]= {
{.name= "SOCK_DGRAM", .enumVal= SOCK_DGRAM},
{.name= "SOCK_RAW", .enumVal= SOCK_RAW},
{.name= "SOCK_STREAM", .enumVal= SOCK_STREAM},
{}
};
const static struct enumTuple ai_protocol_etArr[]= {
{.name= "IPPROTO_TCP", .enumVal= IPPROTO_TCP},
{.name= "IPPROTO_UDP", .enumVal= IPPROTO_UDP},
{}
};
int
addrinfo_print(struct addrinfo *ai, FILE *fh)
/*************************************************************
* Print a legible rendition of all struct addrinfo in the
* linked-list chain.
*
* ai: pinter to a struct addrinfo
* fh: stream for output
*
* RETURNS:
* 0 for success
* -1 for error
*/
{
for(; ai; ai= ai->ai_next) {
const char *addr= addrinfo_2_addr(ai);
ez_fprintf(fh,
"struct addressinfo {\n"
"\tai_flags= %s\n"
"\tai_family= %s\n"
"\tai_socktype= %s\n"
"\tai_protocol= %s\n"
"\tai_addrlen= %d\n"
"\tai_addr= %s\n"
"\tai_cannonname= %s\n"
"}\n"
, bits2str(ai->ai_flags, ai_flags_btArr)
, enum2str(ai->ai_family, ai_family_etArr)
, enum2str(ai->ai_socktype, ai_socktype_etArr)
, enum2str(ai->ai_protocol, ai_protocol_etArr)
, (int)ai->ai_addrlen
, addr ? addr : "NULL"
, ai->ai_canonname ? ai->ai_canonname : "NULL"
);
}
return 0;
}
int
addrinfo_is_match(const struct addrinfo *ai, const char *addr)
/***********************************************************************
* Search all members in addrinfo linked list for a match.
*
* ai: pinter to a struct addrinfo
* addr: NULL terminated numeric address for strcmp() comparison
*
* RETURNS:
* 1 a match was found
* 0 no match was found.
*/
{
for(; ai; ai= ai->ai_next) {
const char *this_addr= addrinfo_2_addr(ai);
if(!strcmp(this_addr, addr))
return 1;
}
return 0;
}
const char*
addrinfo_2_addr(const struct addrinfo *ai)
/***********************************************************************
* Return in a static buffer a sting version of the numeric address found
* in a single addrinfo struct.
*
* ai: pinter to a struct addrinfo
*
* RETURNS:
* NULL for failure
* address of the static buffer containing address in null terminated string form.
*/
{
/* Rotating buffers so this can be used multiple times as arg to printf() */
#define N_BUFS 5
#define BUF_SZ 43
const char *rtn= NULL;
if(!ai->ai_addr) goto abort;
static _Thread_local char bufArr[N_BUFS][BUF_SZ];
static _Thread_local unsigned count;
char *buf= bufArr[++count%N_BUFS];
memset(buf, 0, BUF_SZ);
switch(ai->ai_family) {
case AF_INET: {
struct sockaddr_in *sin= (struct sockaddr_in*)ai->ai_addr;
rtn= inet_ntop(AF_INET, &sin->sin_addr, buf, BUF_SZ-1);
} break;
case AF_INET6: {
struct sockaddr_in6 *sin6= (struct sockaddr_in6*)ai->ai_addr;
rtn= inet_ntop(AF_INET6, &sin6->sin6_addr, buf, BUF_SZ-1);
} break;
default:
assert(0);
}
abort:
return rtn;
#undef BUF_SZ
#undef N_BUFS
}
Посилання в новій задачі View Git Blame Копіювати постійне посилання