tests/server/util.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2010, Daniel Stenberg, <daniel@haxx.se>, et al.
   9  *
  10  * This software is licensed as described in the file COPYING, which
  11  * you should have received as part of this distribution. The terms
  12  * are also available at http://curl.haxx.se/docs/copyright.html.
  13  *
  14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15  * copies of the Software, and permit persons to whom the Software is
  16  * furnished to do so, under the terms of the COPYING file.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ***************************************************************************/
  22
  23 #define CURL_NO_OLDIES
  24
  25 #include "setup.h" /* portability help from the lib directory */
  26
  27 #ifdef HAVE_SIGNAL_H
  28 #include <signal.h>
  29 #endif
  30 #ifdef HAVE_UNISTD_H
  31 #include <unistd.h>
  32 #endif
  33 #ifdef HAVE_SYS_SOCKET_H
  34 #include <sys/socket.h>
  35 #endif
  36 #ifdef HAVE_NETINET_IN_H
  37 #include <netinet/in.h>
  38 #endif
  39 #ifdef _XOPEN_SOURCE_EXTENDED
  40 /* This define is "almost" required to build on HPUX 11 */
  41 #include <arpa/inet.h>
  42 #endif
  43 #ifdef HAVE_NETDB_H
  44 #include <netdb.h>
  45 #endif
  46 #ifdef HAVE_SYS_POLL_H
  47 #include <sys/poll.h>
  48 #elif defined(HAVE_POLL_H)
  49 #include <poll.h>
  50 #endif
  51
  52 #define ENABLE_CURLX_PRINTF
  53 /* make the curlx header define all printf() functions to use the curlx_*
  54    versions instead */
  55 #include "curlx.h" /* from the private lib dir */
  56 #include "getpart.h"
  57 #include "util.h"
  58 #include "timeval.h"
  59
  60 #if defined(ENABLE_IPV6) && defined(__MINGW32__)
  61 const struct in6_addr in6addr_any = {{ IN6ADDR_ANY_INIT }};
  62 #endif
  63
  64 void logmsg(const char *msg, ...)
  65 {
  66   va_list ap;
  67   char buffer[2048 + 1];
  68   FILE *logfp;
  69   int error;
  70   struct timeval tv;
  71   time_t sec;
  72   struct tm *now;
  73   char timebuf[20];
  74   static time_t epoch_offset;
  75   static int    known_offset;
  76
  77   if (!serverlogfile) {
  78     fprintf(stderr, "Error: serverlogfile not set\n");
  79     return;
  80   }
  81
  82   tv = curlx_tvnow();
  83   if(!known_offset) {
  84     epoch_offset = time(NULL) - tv.tv_sec;
  85     known_offset = 1;
  86   }
  87   sec = epoch_offset + tv.tv_sec;
  88   now = localtime(&sec); /* not thread safe but we don't care */
  89
  90   snprintf(timebuf, sizeof(timebuf), "%02d:%02d:%02d.%06ld",
  91     (int)now->tm_hour, (int)now->tm_min, (int)now->tm_sec, (long)tv.tv_usec);
  92
  93   va_start(ap, msg);
  94   vsnprintf(buffer, sizeof(buffer), msg, ap);
  95   va_end(ap);
  96
  97   logfp = fopen(serverlogfile, "ab");
  98   if(logfp) {
  99     fprintf(logfp, "%s %s\n", timebuf, buffer);
 100     fclose(logfp);
 101   }
 102   else {
 103     error = ERRNO;
 104     fprintf(stderr, "fopen() failed with error: %d %s\n",
 105             error, strerror(error));
 106     fprintf(stderr, "Error opening file: %s\n", serverlogfile);
 107     fprintf(stderr, "Msg not logged: %s %s\n", timebuf, buffer);
 108   }
 109 }
 110
 111 #ifdef WIN32
 112 /* use instead of perror() on generic windows */
 113 void win32_perror (const char *msg)
 114 {
 115   char buf[512];
 116   DWORD err = SOCKERRNO;
 117
 118   if (!FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err,
 119                      LANG_NEUTRAL, buf, sizeof(buf), NULL))
 120      snprintf(buf, sizeof(buf), "Unknown error %lu (%#lx)", err, err);
 121   if (msg)
 122      fprintf(stderr, "%s: ", msg);
 123   fprintf(stderr, "%s\n", buf);
 124 }
 125 #endif  /* WIN32 */
 126
 127 #ifdef USE_WINSOCK
 128 void win32_init(void)
 129 {
 130   WORD wVersionRequested;
 131   WSADATA wsaData;
 132   int err;
 133   wVersionRequested = MAKEWORD(USE_WINSOCK, USE_WINSOCK);
 134
 135   err = WSAStartup(wVersionRequested, &wsaData);
 136
 137   if (err != 0) {
 138     perror("Winsock init failed");
 139     logmsg("Error initialising winsock -- aborting");
 140     exit(1);
 141   }
 142
 143   if ( LOBYTE( wsaData.wVersion ) != USE_WINSOCK ||
 144        HIBYTE( wsaData.wVersion ) != USE_WINSOCK ) {
 145
 146     WSACleanup();
 147     perror("Winsock init failed");
 148     logmsg("No suitable winsock.dll found -- aborting");
 149     exit(1);
 150   }
 151 }
 152
 153 void win32_cleanup(void)
 154 {
 155   WSACleanup();
 156 }
 157 #endif  /* USE_WINSOCK */
 158
 159 /* set by the main code to point to where the test dir is */
 160 const char *path=".";
 161
 162 char *test2file(long testno)
 163 {
 164   static char filename[256];
 165   snprintf(filename, sizeof(filename), TEST_DATA_PATH, path, testno);
 166   return filename;
 167 }
 168
 169 /*
 170  * Portable function used for waiting a specific amount of ms.
 171  * Waiting indefinitely with this function is not allowed, a
 172  * zero or negative timeout value will return immediately.
 173  *
 174  * Return values:
 175  *   -1 = system call error, or invalid timeout value
 176  *    0 = specified timeout has elapsed
 177  */
 178 int wait_ms(int timeout_ms)
 179 {
 180 #if !defined(MSDOS) && !defined(USE_WINSOCK)
 181 #ifndef HAVE_POLL_FINE
 182   struct timeval pending_tv;
 183 #endif
 184   struct timeval initial_tv;
 185   int pending_ms;
 186   int error;
 187 #endif
 188   int r = 0;
 189
 190   if(!timeout_ms)
 191     return 0;
 192   if(timeout_ms < 0) {
 193     SET_SOCKERRNO(EINVAL);
 194     return -1;
 195   }
 196 #if defined(MSDOS)
 197   delay(timeout_ms);
 198 #elif defined(USE_WINSOCK)
 199   Sleep(timeout_ms);
 200 #else
 201   pending_ms = timeout_ms;
 202   initial_tv = curlx_tvnow();
 203   do {
 204 #if defined(HAVE_POLL_FINE)
 205     r = poll(NULL, 0, pending_ms);
 206 #else
 207     pending_tv.tv_sec = pending_ms / 1000;
 208     pending_tv.tv_usec = (pending_ms % 1000) * 1000;
 209     r = select(0, NULL, NULL, NULL, &pending_tv);
 210 #endif /* HAVE_POLL_FINE */
 211     if(r != -1)
 212       break;
 213     error = SOCKERRNO;
 214     if(error && (error != EINTR))
 215       break;
 216     pending_ms = timeout_ms - (int)curlx_tvdiff(curlx_tvnow(), initial_tv);
 217     if(pending_ms <= 0)
 218       break;
 219   } while(r == -1);
 220 #endif /* USE_WINSOCK */
 221   if(r)
 222     r = -1;
 223   return r;
 224 }
 225
 226 int write_pidfile(const char *filename)
 227 {
 228   FILE *pidfile;
 229   long pid;
 230
 231   pid = (long)getpid();
 232   pidfile = fopen(filename, "wb");
 233   if(!pidfile) {
 234     logmsg("Couldn't write pid file: %s %s", filename, strerror(ERRNO));
 235     return 0; /* fail */
 236   }
 237   fprintf(pidfile, "%ld\n", pid);
 238   fclose(pidfile);
 239   logmsg("Wrote pid %ld to %s", pid, filename);
 240   return 1; /* success */
 241 }
 242
 243 void set_advisor_read_lock(const char *filename)
 244 {
 245   FILE *lockfile;
 246   int error = 0;
 247   int res;
 248
 249   do {
 250     lockfile = fopen(filename, "wb");
 251   } while((lockfile == NULL) && ((error = ERRNO) == EINTR));
 252   if(lockfile == NULL) {
 253     logmsg("Error creating lock file %s error: %d %s",
 254            filename, error, strerror(error));
 255     return;
 256   }
 257
 258   do {
 259     res = fclose(lockfile);
 260   } while(res && ((error = ERRNO) == EINTR));
 261   if(res)
 262     logmsg("Error closing lock file %s error: %d %s",
 263            filename, error, strerror(error));
 264 }
 265
 266 void clear_advisor_read_lock(const char *filename)
 267 {
 268   int error = 0;
 269   int res;
 270
 271   /*
 272   ** Log all removal failures. Even those due to file not existing.
 273   ** This allows to detect if unexpectedly the file has already been
 274   ** removed by a process different than the one that should do this.
 275   */
 276
 277   do {
 278     res = unlink(filename);
 279   } while(res && ((error = ERRNO) == EINTR));
 280   if(res)
 281     logmsg("Error removing lock file %s error: %d %s",
 282            filename, error, strerror(error));
 283 }