开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
threadsafe.c
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：10k
源码类别：

生物技术

开发平台：

C/C++

threadsafe.c：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: threadsafe.c,v $
  4.  * PRODUCTION Revision 1000.2  2004/04/01 21:01:21  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [CORE_002] Dev-tree R1.4
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* FreeTDS - Library of routines accessing Sybase and Microsoft databases
  11.  * Copyright (C) 1998-2002  Brian Bruns
  12.  *
  13.  * This library is free software; you can redistribute it and/or
  14.  * modify it under the terms of the GNU Library General Public
  15.  * License as published by the Free Software Foundation; either
  16.  * version 2 of the License, or (at your option) any later version.
  17.  *
  18.  * This library is distributed in the hope that it will be useful,
  19.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21.  * Library General Public License for more details.
  22.  *
  23.  * You should have received a copy of the GNU Library General Public
  24.  * License along with this library; if not, write to the
  25.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  26.  * Boston, MA 02111-1307, USA.
  27.  */
  29. #include <tds_config.h>
  30. #ifndef WIN32
  31. #include <netdb.h>
  32. #include <sys/types.h>
  33. #include <netinet/in.h>
  34. #include <arpa/inet.h>
  35. #endif
  36. #include "tds.h"
  37. #include "tdsutil.h"
  38. #ifdef DMALLOC
  39. #include <dmalloc.h>
  40. #endif
  42. static char  software_version[]   = "$Id: threadsafe.c,v 1000.2 2004/04/01 21:01:21 gouriano Exp $";
  43. static void *no_unused_var_warn[] = {software_version,
  44.                                      no_unused_var_warn};
  46. char *
  47. tds_timestamp_str(char *str, int maxlen)
  48. {
  49. struct tm  *tm;
  50. time_t      t;
  51. #ifdef __FreeBSD__
  52. struct timeval  tv;
  53. char usecs[10];
  54. #endif
  55. #ifdef _REENTRANT
  56. struct tm res;
  57. #endif
  59. #ifdef __FreeBSD__
  60. gettimeofday(&tv, NULL);
  61. t = tv.tv_sec;
  62. #else
  63. /*
  64. * XXX Need to get a better time resolution for
  65. * non-FreeBSD systems.
  66. */
  67. time(&t);
  68. #endif
  70. #ifdef _REENTRANT
  71. tm = localtime_r(&t, &res);
  72. #else
  73. tm = localtime(&t);
  74. #endif
  76. strftime(str, maxlen - 6, "%Y-%m-%d %H:%M:%S", tm);
  78. #ifdef __FreeBSD__
  79.     sprintf(usecs, ".%06lu", tv.tv_usec);
  80. strcat(str, usecs);
  81. #endif
  83. return str;
  84. }
  86. #if (defined(HAVE_GETADDRINFO) || defined(HAVE_GETNAMEINFO))  &&  defined(_REENTRANT)
  87. static
  88. int s_make_hostent(struct hostent* he, char* buf, int len, const struct addrinfo* ai)
  89. {
  90. static int ptr_size = sizeof(char*);
  91. int pos = 0, namelen, addrnum = 0, maxaddrs;
  92. const struct addrinfo* it;
  94. memset(he, 0, sizeof(*he));
  96. namelen = strlen(ai->ai_canonname);
  97. if (pos + namelen >= len) {
  98. return NO_RECOVERY;
  99. }
  100. if (he->h_name != ai->ai_canonname) {
  101. /* already present in dummy structure passed by tds_ghba_r */
  102. he->h_name = strcpy(buf + pos, ai->ai_canonname);
  103. }
  104. pos += namelen;
  106. pos += ptr_size - ((pos + (size_t)buf) % ptr_size); /* align */
  107. if (pos + ptr_size > len) {
  108. return NO_RECOVERY;
  109. }
  110. he->h_aliases = (char**)(buf + pos);
  111. he->h_aliases[0] = 0;
  112. pos += ptr_size;
  114. he->h_addrtype = ai->ai_family;
  115. he->h_length = ai->ai_addrlen;
  116. if (pos + ptr_size > len) {
  117. return NO_RECOVERY;
  118. }
  119. he->h_addr_list = (char**)(buf + pos);
  120. pos += ptr_size;
  121. maxaddrs = (len - pos) / (ptr_size + ai->ai_addrlen);
  122. if (maxaddrs == 0) {
  123. he->h_addr_list[0] = 0;
  124. return NO_RECOVERY;
  125. }
  126. pos += ptr_size * maxaddrs;
  128. for (it = ai;  it != 0  &&  addrnum < maxaddrs;  it = it->ai_next) {
  129. if (it->ai_family == ai->ai_family) {
  130. switch (ai->ai_family) {
  131. case PF_INET:
  132. memcpy(buf + pos,
  133.        &((struct sockaddr_in*)(it->ai_addr))
  134.            ->sin_addr,
  135.        it->ai_addrlen);
  136. break;
  137. case PF_INET6:
  138. memcpy(buf + pos,
  139.        &((struct sockaddr_in6*)(it->ai_addr))
  140.            ->sin6_addr,
  141.        it->ai_addrlen);
  142. break;
  143. }
  144. he->h_addr_list[addrnum] = buf + pos;
  145. pos += it->ai_addrlen;
  146. ++addrnum;
  147. }
  148. }
  149. he->h_addr_list[addrnum] = 0;
  151. return 0;
  152. }
  154. static
  155. int s_convert_ai_errno(int ai_errno)
  156. {
  157. switch (ai_errno) {
  158. case EAI_NONAME:      return HOST_NOT_FOUND;
  159. case EAI_ADDRFAMILY:  return NO_ADDRESS;
  160. case EAI_NODATA:      return NO_DATA;
  161. case EAI_FAIL:        return NO_RECOVERY;
  162. case EAI_AGAIN:       return TRY_AGAIN;
  163. default:              return TRY_AGAIN;
  164. }
  165. }
  166. #endif
  168. struct hostent   *
  169. tds_gethostbyname_r(const char *servername, struct hostent *result, char *buffer, int buflen, int *h_errnop)
  170. {
  171. #ifndef _REENTRANT
  172.         return gethostbyname(servername);
  174. #else
  176. #if defined(HAVE_FUNC_GETHOSTBYNAME_R_6)
  177. if (gethostbyname_r(servername, result, buffer, buflen, &result, h_errnop))
  178. return NULL;
  180. #elif defined(HAVE_FUNC_GETHOSTBYNAME_R_5)
  181.         gethostbyname_r(servername, result, buffer, buflen, h_errnop);
  182. #elif defined(HAVE_FUNC_GETHOSTBYNAME_R_3)
  183. struct hostent_data data;
  184. gethostbyname_r(servername, result, &data);
  185. #elif defined(HAVE_GETADDRINFO)
  186. struct addrinfo hints, *out = 0;
  187. int ai_errno;
  189. memset(&hints, 0, sizeof(hints));
  190. hints.ai_family = PF_INET;
  191. ai_errno = getaddrinfo(servername, 0, &hints, &out);
  192. if (ai_errno == 0  &&  out) {
  193. *h_errnop = s_make_hostent(result, buffer, buflen, out);
  194. } else {
  195. *h_errnop = s_convert_ai_errno(ai_errno);
  196. }
  197. if (out) {
  198. freeaddrinfo(out);
  199. }
  200. #elif defined(_REENTRANT)
  201. #error gethostbyname_r style unknown and getaddrinfo unavailable
  202. #endif
  204.         return result;
  205. #endif
  206. }
  208. #if defined(HAVE_GETNAMEINFO)  &&  defined(_REENTRANT)
  209. #  ifndef HAVE_SOCKLEN_T
  210. typedef int socklen_t;
  211. #  endif
  213. static
  214. socklen_t s_make_sa(const char *addr, int len, int type, void *buf, int blen)
  215. {
  216. switch (type) {
  217. case PF_INET:
  218. {
  219. struct sockaddr_in* sain = (struct sockaddr_in*)buf;
  220. if (sizeof(*sain) > blen) {
  221. return 0;
  222. }
  223. memset(sain, 0, sizeof(*sain));
  224. sain->sin_family = type;
  225. memcpy(&sain->sin_addr, addr, len);
  226. #ifdef HAVE_SIN_LEN
  227. sain->sin_len = len;
  228. #endif
  229. return sizeof(*sain);
  230. }
  232. #ifdef PF_INET6
  233. case PF_INET6:
  234. {
  235. struct sockaddr_in6* sa6 = (struct sockaddr_in6*)buf;
  236. if (sizeof(*sa6) > blen) {
  237. return 0;
  238. }
  239. memset(sa6, 0, sizeof(*sa6));
  240. sa6->sin6_family = type;
  241. memcpy(&sa6->sin6_addr, addr, len);
  242. #ifdef HAVE_SIN_LEN
  243. sa6->sin6_len = len;
  244. #endif
  245. return sizeof(*sa6);
  246. }
  247. #endif
  249. default:
  250. return 0;
  251. }
  253. }
  254. #endif
  256. struct hostent   *
  257. tds_gethostbyaddr_r(const char *addr, int len, int type, struct hostent *result, char *buffer, int buflen, int *h_errnop)
  258. {
  259. #ifndef _REENTRANT
  260.         return gethostbyaddr(addr, len, type);
  262. #else
  264. #if defined(HAVE_FUNC_GETHOSTBYADDR_R_8)
  265. if (gethostbyaddr_r(addr, len, type, result, buffer, buflen, &result, h_errnop))
  266. return NULL;
  267. #elif defined(HAVE_FUNC_GETHOSTBYADDR_R_7)
  268.         gethostbyaddr_r(addr, len, type, result, buffer, buflen, h_errnop);
  269. #elif defined(HAVE_FUNC_GETHOSTBYADDR_R_5)
  270. struct hostent_data data;
  271. gethostbyaddr_r(addr, len, type, result, &data);
  272. #elif defined(HAVE_GETNAMEINFO)
  273. struct sockaddr* sa = (struct sockaddr*)buffer;
  274. socklen_t salen;
  275. int ai_errno;
  277. salen = s_make_sa(addr, len, type, buffer, buflen);
  278. if (salen <= 0) {
  279. *h_errnop = NO_RECOVERY;
  280. return NULL;
  281. }
  282. ai_errno = getnameinfo(sa, salen, buffer + salen, buflen - salen, 0, 0, 0);
  283. if (ai_errno == 0) {
  284. struct addrinfo ai; /* much easier to construct than hostent */
  285. ai.ai_family  = type;
  286. ai.ai_addrlen  = salen;
  287. ai.ai_addr  = sa;
  288. ai.ai_canonname = buffer + salen;
  289. ai.ai_next  = 0;
  290. *h_errnop = s_make_hostent(result, buffer + salen, buflen - salen, &ai);
  291. } else {
  292. *h_errnop = s_convert_ai_errno(ai_errno);
  293. }
  294. #else
  295. #error gethostbyaddr_r style unknown and getnameinfo unavailable
  296. #endif
  298.         return result;
  299. #endif
  300. }
  302. #if defined(HAVE_GETADDRINFO)  &&  defined(_REENTRANT)
  303. static
  304. int s_make_servent(struct servent* se, char* buf, int len, const struct addrinfo* ai, const char* name, const char* proto)
  305. {
  306. static int ptr_size = sizeof(char*);
  307. int pos = 0, namelen;
  308. const struct addrinfo* it;
  310. memset(se, 0, sizeof(*se));
  312. namelen = strlen(name);
  313. if (pos + namelen >= len) {
  314. return NO_RECOVERY;
  315. }
  316. se->s_name = strcpy(buf + pos, ai->ai_canonname);
  317. pos += namelen;
  319. pos += ptr_size - ((pos + (size_t)buf) % ptr_size); /* align */
  320. if (pos + ptr_size > len) {
  321. return NO_RECOVERY;
  322. }
  323. se->s_aliases = (char**)(buf + pos);
  324. se->s_aliases[0] = 0;
  325. pos += ptr_size;
  327. switch (ai->ai_family) {
  328. case PF_INET:
  329. se->s_port = ((struct sockaddr_in*)(it->ai_addr))->sin_port;
  330. break;
  331. case PF_INET6:
  332. se->s_port = ((struct sockaddr_in6*)(it->ai_addr))->sin6_port;
  333. break;
  334. }
  335. if (proto  &&  pos + strlen(proto) < len) {
  336. se->s_proto = strcpy(buf + pos, proto);
  337. pos += strlen(proto) + 1;
  338. }
  340. return 0;
  341. }
  342. #endif
  344. struct servent *
  345. tds_getservbyname_r(const char *name, char *proto, struct servent *result, char *buffer, int buflen)
  346. {
  348. #ifndef _REENTRANT
  349.         return getservbyname(name, proto);
  351. #else
  353. #if defined(HAVE_FUNC_GETSERVBYNAME_R_6)
  354. if (getservbyname_r(name, proto, result, buffer, buflen, &result))
  355. return NULL;
  356. #elif defined(HAVE_FUNC_GETSERVBYNAME_R_5)
  357.         getservbyname_r(name, proto, result, buffer, buflen);
  358. #elif defined(HAVE_FUNC_GETSERVBYNAME_R_4)
  359. struct servent_data data;
  360. getservbyname_r(name, proto, result, &data);
  361. #elif defined(HAVE_GETADDRINFO)
  362. struct addrinfo hints, *out = 0;
  363. struct protoent* pe;
  364. int status;
  366. memset(&hints, 0, sizeof(hints));
  367. hints.ai_family = PF_INET;
  368. if (proto) {
  369. pe = getprotobyname(proto);
  370. if (pe) {
  371. /* might as well canonicalize */
  372. proto             = pe->p_name;
  373. hints.ai_protocol = pe->p_proto;
  374. }
  375. }
  376. status = getaddrinfo(0, name, &hints, &out);
  377. if (status == 0  &&  out) {
  378. status = s_make_servent(result, buffer, buflen, out, name, proto);
  379. if (status != 0) {
  380. result = 0;
  381. }
  382. } else {
  383. result = 0;
  384. }
  385. if (out) {
  386. freeaddrinfo(out);
  387. }
  388. #else
  389. #error getservbyname_r style unknown and getaddrinfo unavailable
  390. #endif
  392.         return result;
  393. #endif
  394. }
  397. char *
  398. tds_strtok_r(char *s, const char *delim, char **ptrptr)
  399. {
  400. #ifdef _REENTRANT
  401. return strtok_r(s, delim, ptrptr);
  402. #else
  403. return strtok(s, delim);
  404. #endif
  405. }