[BACK]Return to pa_common.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/pa_common.C between versions 1.116 and 1.143.2.9

version 1.116, 2002/08/05 13:58:45 version 1.143.2.9, 2003/01/31 12:10:47
Line 1 Line 1
 /** @file  /** @file
         Parser: commonly functions.          Parser: commonly functions.
   
         Copyright(c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)          Copyright(c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com)
         Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */  */
   
 static const char* IDENT_COMMON_C="$Date$";  static const char* IDENT_COMMON_C="$Date$"; 
   
 #include "pa_common.h"  #include "pa_common.h"
 #include "pa_types.h"  
 #include "pa_exception.h"  #include "pa_exception.h"
 #include "pa_pool.h"  #include "pa_value_includes.h"
 #include "pa_globals.h"  
 #include "pa_value.h"  
 #include "pa_hash.h"  #include "pa_hash.h"
 #include "pa_string.h"  #include "pa_vstring.h"
   #include "pa_vint.h"
   
 #ifdef WIN32  #ifdef WIN32
 #       include <windows.h>  #       include <windows.h>
   #else
   #       define closesocket close
 #endif  #endif
   
 // some maybe-undefined constants  // some maybe-undefined constants
Line 28  static const char* IDENT_COMMON_C="$Date Line 28  static const char* IDENT_COMMON_C="$Date
 #ifndef _O_BINARY  #ifndef _O_BINARY
 #       define _O_BINARY 0  #       define _O_BINARY 0
 #endif  #endif
 #ifndef O_TRUNC  
 #       define O_TRUNC 0  #ifdef HAVE_FTRUNCATE
   #       define PA_O_TRUNC 0
   #else
   #       ifdef _O_TRUNC
   #               define PA_O_TRUNC _O_TRUNC
   #       else
   #               error you must have either ftruncate function or _O_TRUNC bit declared
   #       endif
 #endif  #endif
   
 // locking constants  // locking constants
Line 44  static int unlock(int fd) { return flock Line 51  static int unlock(int fd) { return flock
 #else  #else
 #ifdef HAVE__LOCKING  #ifdef HAVE__LOCKING
   
 #define FLOCK(operation) lseek(fd, 0, SEEK_SET); return _locking(fd, operation, 1)  #define FLOCK(operation) lseek(fd, 0, SEEK_SET);  return _locking(fd, operation, 1)
 static int lock_shared_blocking(int fd) { FLOCK(_LK_LOCK); }  static int lock_shared_blocking(int fd) { FLOCK(_LK_LOCK); }
 static int lock_exclusive_blocking(int fd) { FLOCK(_LK_LOCK); }  static int lock_exclusive_blocking(int fd) { FLOCK(_LK_LOCK); }
 static int lock_exclusive_nonblocking(int fd) { FLOCK(_LK_NBLCK); }  static int lock_exclusive_nonblocking(int fd) { FLOCK(_LK_NBLCK); }
Line 53  static int unlock(int fd) { FLOCK(_LK_UN Line 60  static int unlock(int fd) { FLOCK(_LK_UN
 #else  #else
 #ifdef HAVE_FCNTL  #ifdef HAVE_FCNTL
   
 #define FLOCK(cmd, arg) struct flock ls={arg, SEEK_SET}; return fcntl(fd, cmd, &ls)  #define FLOCK(cmd, arg) struct flock ls={arg, SEEK_SET};  return fcntl(fd, cmd, &ls)
 static int lock_shared_blocking(int fd) { FLOCK(F_SETLKW, F_RDLCK); }  static int lock_shared_blocking(int fd) { FLOCK(F_SETLKW, F_RDLCK); }
 static int lock_exclusive_blocking(int fd) { FLOCK(F_SETLKW, F_WRLCK); }  static int lock_exclusive_blocking(int fd) { FLOCK(F_SETLKW, F_WRLCK); }
 static int lock_exclusive_nonblocking(int fd) { FLOCK(F_SETLK, F_RDLCK); }  static int lock_exclusive_nonblocking(int fd) { FLOCK(F_SETLK, F_RDLCK); }
Line 62  static int unlock(int fd) { FLOCK(F_SETL Line 69  static int unlock(int fd) { FLOCK(F_SETL
 #else  #else
 #ifdef HAVE_LOCKF  #ifdef HAVE_LOCKF
   
 #define FLOCK(fd, operation) lseek(fd, 0, SEEK_SET); return lockf(fd, operation, 1)  #define FLOCK(fd, operation) lseek(fd, 0, SEEK_SET);  return lockf(fd, operation, 1)
 static int lock_shared_blocking(int fd) { FLOCK(F_LOCK); } // on intel solaris man doesn't have doc on shared blocking  static int lock_shared_blocking(int fd) { FLOCK(F_LOCK); } // on intel solaris man doesn't have doc on shared blocking
 static int lock_exclusive_blocking(int fd) { FLOCK(F_LOCK); }  static int lock_exclusive_blocking(int fd) { FLOCK(F_LOCK); }
 static int lock_exclusive_nonblocking(int fd) { FLOCK(F_TLOCK); }  static int lock_exclusive_nonblocking(int fd) { FLOCK(F_TLOCK); }
Line 77  static int unlock(int fd) { FLOCK(F_TLOC Line 84  static int unlock(int fd) { FLOCK(F_TLOC
 #endif  #endif
 #endif  #endif
   
 static char *strnchr(char *buf, size_t size, char c) {  #define DEFAULT_USER_AGENT "parser3"
         // sanity check  
         if(!buf)  
                 return 0;  
   
         for(; size-->0; buf++) {  
                 if(*buf==c)  
                         return buf;  
         }  
   
         return 0;  void fix_line_breaks(char* buf, size_t& size) {
 }          if(size==0)
                   return;
   
 void fix_line_breaks(char *buf, size_t& size) {  
         //_asm int 3;          //_asm int 3;
         const char * const eob=buf+size;          const char* const eob=buf+size;
         char *dest=buf;          char* dest=buf;
         // fix DOS: \r\n -> \n          // fix DOS: \r\n -> \n
         // fix Macintosh: \r -> \n          // fix Macintosh: \r -> \n
         char *bol=buf;          char* bol=buf;
         while(char *eol=strnchr(bol, eob -bol, '\r')) {          while(char* eol=(char*)memchr(bol, '\r', eob -bol)) {
                 size_t len=eol-bol;                  size_t len=eol-bol;
                 if(dest!=bol)                  if(dest!=bol)
                         memcpy(dest, bol, len);                          memcpy(dest, bol, len); 
                 dest+=len;                  dest+=len;
                 *dest++='\n';                  *dest++='\n'; 
   
                 if(&eol[1]<eob && eol[1]=='\n') { // \r,\n = DOS                  if(&eol[1]<eob && eol[1]=='\n') { // \r, \n = DOS
                         bol=eol+2;                          bol=eol+2;
                         size--;                          size--; 
                 } else // \r,not \n = Macintosh                  } else // \r, not \n = Macintosh
                         bol=eol+1;                          bol=eol+1;
         }          }
         // last piece without \r, including terminating 0          // last piece without \r, including terminating 0
         if(dest!=bol)          if(dest!=bol)
                 memcpy(dest, bol, eob-bol);                  memcpy(dest, bol, eob-bol); 
   }
   
   char* file_read_text(Pool& pool, Charset& charset, 
                                            StringPtr file_spec, 
                                            bool fail_on_read_problem,
                                            HashStringValue *params, HashStringValue** out_fields) {
           char *result;  size_t size;
           File_read_result file_read_result=file_read(pool, charset, file_spec, result, size, true, params, out_fields, fail_on_read_problem);
           return file_read_result.success?result:0;
   }
   
   //http request stuff
   /* ************************ http stuff *********************** */
   
   static bool set_addr(struct sockaddr_in *addr, const char* host, const short port){
       memset(addr, 0, sizeof(*addr)); 
       addr->sin_family=AF_INET;
       addr->sin_port=htons(port); 
       if(host) {
                   if(struct hostent *hostIP=gethostbyname(host)) 
                           memcpy(&addr->sin_addr, hostIP->h_addr, hostIP->h_length); 
                   else
                           return false;
       } else 
                   addr->sin_addr.s_addr=INADDR_ANY;
       return true;
   }
   
   static int http_read_response(Pool& pool, String& response, int sock, bool fail_on_status_ne_200){
           int result=0;
           ssize_t EOLat=0;
           while(true) {
                   char *buf=(char *)pool.malloc(MAX_STRING); 
                   ssize_t size=recv(sock, buf, MAX_STRING, 0); 
                   if(size<=0)
                           break;
                   response.APPEND_TAINTED(buf, size, "remote HTTP server response", 0); 
                   if(!result && (EOLat=response.pos("\r\n", 2))>=0) { // checking status in first response
                           StringPtr status_line=response.mid(0, (size_t)EOLat);
                           Array<StringPtr> astatus; 
                           status_line->split(astatus, 0, " ", 1); 
                           StringPtr status_code=astatus.get(1);
                           result=status_code->as_int(); 
   
                           if(fail_on_status_ne_200 && result!=200)
                                   throw Exception("http.status",
                                           status_code,
                                           "invalid HTTP response status");
                   }
           }
           if(result)
                   return result;
           else
                   throw Exception("http.response",
                           Exception::undefined_source,
                           "bad response from host - no status found (size=%lu)", response.size()); 
   }
   
   /* ********************** request *************************** */
   
   #if defined(SIGALRM) && defined(HAVE_SIGSETJMP) && defined(HAVE_SIGLONGJMP)
   #       define WE_CAN_USE_ALARM
   #endif
   
   #ifdef WE_CAN_USE_ALARM
   static sigjmp_buf timeout_env;
   static void timeout_handler(int sig){
       siglongjmp(timeout_env, 1); 
   }
   #endif
   
   static int http_request(Pool& pool,
                                                   String& response,
                                                   StringPtr origin_string, 
                                                   const char* host, int port, 
                                                   const char* request, 
                                                   int timeout,
                                                   bool fail_on_status_ne_200) {
           if(!host)
                   throw Exception("http.host", 
                           origin_string, 
                           "zero hostname");  //never
   
   #ifdef WE_CAN_USE_ALARM
       signal(SIGALRM, timeout_handler); 
   #endif
           int sock=-1;
           try {
                   int result;
   #ifdef WE_CAN_USE_ALARM
                   if(sigsetjmp(timeout_env, 1))
                           throw Exception("http.timeout", 
                                   origin_string, 
                                   "timeout occured while retrieving document"); 
                   else {
                           alarm(timeout); 
   #endif
                           struct sockaddr_in dest;
                   
                   if(!set_addr(&dest, host, port))
                                   throw Exception("http.host", 
                                           origin_string, 
                                           "can not resolve hostname \"%s\"", host); 
                           
                           if((sock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP/*0*/))<0)
                                   throw Exception("http.connect", 
                                           origin_string, 
                                           "can not make socket: %s (%d)", strerror(errno), errno); 
                           if(connect(sock, (struct sockaddr *)&dest, sizeof(dest)))
                                   throw Exception("http.connect", 
                                           origin_string, 
                                           "can not connect to host \"%s\": %s (%d)", host, strerror(errno), errno); 
                           size_t request_size=strlen(request);
                           if(send(sock, request, request_size, 0)!=(ssize_t)request_size)
                                   throw Exception("http.connect", 
                                           origin_string, 
                                           "error sending request: %s (%d)", strerror(errno), errno); 
   
                           result=http_read_response(pool, response, sock, fail_on_status_ne_200); 
                           closesocket(sock); 
   #ifdef WE_CAN_USE_ALARM
                           alarm(0); 
                   }
   #endif
                   return result;
           } catch(...) {
                   if(sock>=0) 
                           closesocket(sock); 
   #ifdef WE_CAN_USE_ALARM
                   alarm(0); 
   #endif
                   /*re*/throw;
           }
   }
   
   #ifndef DOXYGEN
   struct Http_pass_header_info {
           Pool* pool;
           Charset* charset;
           String* request;
           bool user_agent_specified;
   };
   #endif
   static void http_pass_header(HashStringValue::key_type key, HashStringValue::value_type value, 
                                                            Http_pass_header_info *info) {
       *(info->request)<<*key<<": "
                   << *attributed_meaning_to_string(*info->pool, value, String::UL_HTTP_HEADER, false)
                   <<"\n"; 
           
           if(*key->change_case(*info->pool, *info->charset, String::CC_UPPER)=="USER-AGENT")
                   info->user_agent_specified=true;
 }  }
   static HashStringValuePtr file_read_http(Pool& pool, Charset& charset, StringPtr file_spec, 
                                           char*& data, size_t& data_size, 
                                           HashStringValue *options=0, bool return_outfields=false) {
           HashStringValuePtr result(0);
           char host[MAX_STRING]; 
           const char* uri; 
           int port;
           CharPtr method(0);
           int timeout=2;
           bool fail_on_status_ne_200=true;
           ValuePtr vheaders(0);
   
           StringPtr connect_string(new String());
           // not in ^sql{... UL_SQL ...} spirit, but closer to ^file::load one
           connect_string->append(*file_spec, String::UL_URI); // tainted pieces -> URI pieces
   
           CharPtr connect_string_cstr=connect_string->cstr(String::UL_UNSPECIFIED); 
           const char *current=connect_string_cstr;
           if(strncmp(current, "http://", 7)!=0)
                   throw Exception(0, 
                           connect_string, 
                           "does not start with http://"); //never
           current+=7;
   
           strncpy(host, current, sizeof(host)-1);  host[sizeof(host)-1]=0;
           char* host_uri=lsplit(host, '/'); 
           uri=host_uri?current+(host_uri-1-host):"/"; 
           char* port_cstr=lsplit(host, ':'); 
           char* error_pos=0;
           port=port_cstr?strtol(port_cstr, &error_pos, 0):80;
   
           if(options) {
                   int valid_options=0;
                   if(ValuePtr vmethod=options->get(http_method_name)) {
                           valid_options++;
                           method=vmethod->as_string(&pool)->cstr();
                   }
                   if(ValuePtr vtimeout=options->get(http_timeout_name)) {
                           valid_options++;
                           timeout=vtimeout->as_int(); 
                   }
                   if(vheaders=options->get(http_headers_name)) {
                           valid_options++;
                   }
                   if(ValuePtr vany_status=options->get(http_any_status_name)) {
                           valid_options++;
                           fail_on_status_ne_200=!vany_status->as_bool(); 
                   }
   
                   if(valid_options!=options->count())
                           throw Exception("parser.runtime",
                                   Exception::undefined_source,
                                   "invalid option passed");
           } 
   
           //making request
           String request;
           if(method)
                   request<<method;
           else
                   request<<"GET";
           request<< " "<< uri <<" HTTP/1.0\nHost: "<< host<<"\n"; 
           bool user_agent_specified=false;
           if(vheaders && !vheaders->is_string()) { // allow empty
                   if(HashStringValue *headers=vheaders->get_hash(connect_string)) {
                           Http_pass_header_info info={&pool, &charset, &request};
                           headers->for_each(http_pass_header, &info); 
                           user_agent_specified=info.user_agent_specified;
                   } else
                           throw Exception("parser.runtime", 
                                   connect_string,
                                   "headers param must be hash"); 
           };
           if(!user_agent_specified) // defaulting
                   request << "user-agent: " DEFAULT_USER_AGENT "\n";
           request<<"\n"; 
           
           //sending request
           String response;
           CharPtr request_cstr=request.cstr(String::UL_UNSPECIFIED);
           int status_code=http_request(pool, response,
                   connect_string, host, port, request_cstr, 
                   timeout, fail_on_status_ne_200); 
           
           //processing results    
           int pos=response.pos("\r\n\r\n", 4); 
           if(pos<1){
                   throw Exception("http.response", 
                           connect_string,
                           "bad response from host - no headers found"); 
           }
           StringPtr header_block=response.mid(0, pos); 
           StringPtr body=response.mid(pos+4, response.size()); 
           
           Array<StringPtr> aheaders;
           HashStringValuePtr headers(new HashStringValue); 
           header_block->split(aheaders, 0, "\r\n", 2); 
           
           //processing headers
           for(int i=1; i<aheaders.count(); i++) {
                   StringPtr line=aheaders.get(i);
                   pos=line->pos(": ", 2); 
                   if(pos<1)
                           throw Exception("http.response", 
                                   connect_string,
                                   "bad response from host - bad header \"%s\"", line->cstr()); 
                           
                   headers->put(
                           line->mid(0, pos)->change_case(pool, charset, String::CC_UPPER), 
                           ValuePtr(new VString(line->mid(pos+2, line->size())))); 
           }
   
 char *file_read_text(Pool& pool, const String& file_spec, bool fail_on_read_problem) {          // output response
         void *result;  size_t size;          data=new(pool) char[data_size=body->size()];
         return file_read(pool, file_spec, result, size, true, fail_on_read_problem)?(char *)result:0;          body->store_to(data, String::UL_AS_IS);
 }          if(return_outfields) {
 bool file_read(Pool& pool, const String& file_spec,                   headers->put(file_status_name, ValuePtr(new VInt(status_code))); 
                            void*& data, size_t& data_size, bool as_text,                  return headers;
                            bool fail_on_read_problem,          } else
                            size_t offset, size_t limit) {                  return HashStringValuePtr(0);
         const char *fname=file_spec.cstr(String::UL_FILE_SPEC);  }
 //printf("file_read(%s)\n", fname);  
   #ifndef DOXYGEN
   struct File_read_action_info {
           char **data; size_t *data_size;
   }; 
   #endif
   static void file_read_action(Pool& pool,
                                                            struct stat& finfo, 
                                                            int f, 
                                                            StringPtr file_spec, const char* fname, bool as_text, 
                                                            void *context) {
           File_read_action_info& info=*static_cast<File_read_action_info *>(context); 
           if(size_t to_read_size=(size_t)finfo.st_size) { 
                   *info.data=pool.malloc(to_read_size+(as_text?1:0)); 
                   *info.data_size=(size_t)read(f, *info.data, to_read_size); 
   
                   if(ssize_t(*info.data_size)<0 || *info.data_size>to_read_size)
                           throw Exception(0, 
                                   file_spec, 
                                   "read failed: actually read %lu bytes count not in [0..%lu] valid range", 
                                           *info.data_size, to_read_size); 
           } else { // empty file
                   if(as_text) {
                           *info.data=pool.malloc(1); 
                           *(char*)(*info.data)=0;
                   } else 
                           *info.data=0;
                   *info.data_size=0;
                   return;
           }
   }
   File_read_result file_read(Pool& pool, Charset& charset, StringPtr file_spec, 
                              char*& data, size_t& data_size, 
                              bool as_text, HashStringValue *params, HashStringValue** out_fields, 
                              bool fail_on_read_problem) {
           File_read_result result;
           if(file_spec->starts_with("http://", 7)) {
                   // fail on read problem
                   result.fields=file_read_http(pool, charset, file_spec, data, data_size, params); 
                   result.success=true;
           } else {
                   File_read_action_info info={&data, &data_size}; 
                   result.success=file_read_action_under_lock(pool, file_spec, 
                           "read", file_read_action, &info, 
                           as_text, fail_on_read_problem); 
           }
   
           if(result.success && as_text) {
                   // UTF-8 signature: EF BB BF
                   if(data_size>=3) {
                           char *in=(char *)data;
                           if((in[0] == '\xEF') && (in[1] == '\xBB') &&
                                   (in[2] == '\xBF')) {
                                   data=in+3; data_size-=3;// skip prefix
                           }
                   }
   
                   fix_line_breaks((char *)(data), data_size); 
                   // note: after fixing
                   ((char*&)(data))[data_size]=0;
           }
   
           return result;
   }
   
   bool file_read_action_under_lock(Pool& pool, StringPtr file_spec, 
                                   const char* action_name, File_read_action action, void *context, 
                                   bool as_text, 
                                   bool fail_on_read_problem) {
           CharPtr fname=file_spec->cstr(String::UL_FILE_SPEC); 
         int f;          int f;
     struct stat finfo;  
   
         // first open, next stat:          // first open, next stat:
         // directory update of NTFS hard links performed on open.          // directory update of NTFS hard links performed on open.
         // ex:           // ex: 
         //   a.html:^test[] and b.html hardlink to a.html          //   a.html:^test[] and b.html hardlink to a.html
         //   user inserts ! before ^test in a.html          //   user inserts ! before ^test in a.html
         //   directory entry of b.html in NTFS not updated at once,          //   directory entry of b.html in NTFS not updated at once, 
         //   they delay update till open, so we would receive "!^test[" string          //   they delay update till open, so we would receive "!^test[" string
         //   if would do stat, next open.          //   if would do stat, next open.
           // later: it seems, even this does not help sometimes
     if((f=open(fname, O_RDONLY|(as_text?_O_TEXT:_O_BINARY)))>=0) {      if((f=open(fname, O_RDONLY|(as_text?_O_TEXT:_O_BINARY)))>=0) {
                 if(lock_shared_blocking(f)!=0) {                  try {
                         Exception e("file.lock",                          if(lock_shared_blocking(f)!=0)
                                         &file_spec,                                   throw Exception("file.lock", 
                                         "shared lock failed: %s (%d), actual filename '%s'",                                                   file_spec, 
                                                 strerror(errno), errno, fname);                                                  "shared lock failed: %s (%d), actual filename '%s'", 
                         unlock(f);                                                          strerror(errno), errno, fname); 
                         close(f);  
                         if(fail_on_read_problem)                          struct stat finfo;
                                 throw e;                          if(stat(fname, &finfo)!=0)
                         return false;                                  throw Exception("file.missing", // hardly possible: we just opened it OK
                 }                                          file_spec, 
                 if(stat(fname, &finfo)!=0) {  
                         Exception e("file.missing",  
                                         &file_spec,   
                                         "stat failed: %s (%d), actual filename '%s'",                                           "stat failed: %s (%d), actual filename '%s'", 
                                                 strerror(errno), errno, fname);                                                  strerror(errno), errno, fname); 
                         unlock(f);  
                         close(f);  #ifdef PA_SAFE_MODE
                         if(fail_on_read_problem)                          if(finfo.st_uid/*foreign?*/!=geteuid()
                                 throw e;                                  && finfo.st_gid/*foreign?*/!=getegid())
                         return false;                                  throw Exception("parser.runtime", 
                 }                                          file_spec, 
 #ifdef NO_FOREIGN_GROUP_FILES                                          "parser is in safe mode: reading files of foreign group and user disabled [recompile parser with --disable-safe-mode configure option], actual filename '%s'", 
                 if(finfo.st_gid/*foreign?*/!=getegid()) {                                                  fname); 
                         Exception e("parser.runtime",  
                                 &file_spec,  
                                 "parser reading files of foreign group disabled [recompile parser without --disable-foreign-group-files configure option], actual filename '%s'",   
                                         fname);  
                         unlock(f);  
                         close(f);  
                         if(fail_on_read_problem)  
                                 throw e;  
                         return false;  
                 }  
 #endif  #endif
                 size_t max_size=limit?min(offset+limit, (size_t)finfo.st_size)-offset:finfo.st_size;  
                 if(!max_size) { // eof  
                         if(as_text) {  
                                 data=pool.malloc(1);  
                                 *(char*)data=0;  
                         } else   
                                 data=0;  
                         data_size=0;  
                 } else {  
                         data=pool.malloc(max_size+(as_text?1:0), 3);  
                         if(offset)  
                                 lseek(f, offset, SEEK_SET);  
                         data_size=read(f, data, max_size);  
                 }  
                 unlock(f);  
                 close(f);  
                 if(!max_size) // eof  
                         return true;  
   
                 if(int(data_size)<0 || data_size>max_size)  
                         throw Exception(0,  
                                 &file_spec,   
                                 "read failed: actually read %d bytes count not in [0..%lu] valid range",   
                                         data_size, (unsigned long)max_size); //never  
   
                 if(as_text) {                          action(pool, finfo, f, file_spec, fname, as_text, context); 
                         fix_line_breaks((char *)data, data_size);                  } catch(...) {
                         // note: after fixing                          unlock(f);close(f); 
                         ((char*&)data)[data_size]=0;                          if(fail_on_read_problem)
                 }                                  /*re*/throw;
                           return false;                   
                   } 
   
                   unlock(f);close(f); 
                 return true;                  return true;
     }      } else {
         if(fail_on_read_problem)                  if(fail_on_read_problem)
                 throw Exception(errno==EACCES?"file.access":errno==ENOENT?"file.missing":0,                          throw Exception(errno==EACCES?"file.access":errno==ENOENT?"file.missing":0, 
                         &file_spec,                                   file_spec, 
                         "read failed: %s (%d), actual filename '%s'",                                   "%s failed: %s (%d), actual filename '%s'", 
                                 strerror(errno), errno, fname);                                          action_name, strerror(errno), errno, fname); 
     return false;                  return false;
           }
 }  }
   
 static void create_dir_for_file(const String& file_spec) {  static void create_dir_for_file(StringPtr file_spec) {
         size_t pos_after=1;          size_t pos_after=1;
         int pos_before;          int pos_before;
         while((pos_before=file_spec.pos("/", 1, pos_after))>=0) {          while((pos_before=file_spec->pos("/", 1, pos_after))>=0) {
                 mkdir(file_spec.mid(0, pos_before).cstr(String::UL_FILE_SPEC), 0775);                  mkdir(file_spec->mid(0, pos_before)->cstr(String::UL_FILE_SPEC), 0775); 
                 pos_after=pos_before+1;                  pos_after=pos_before+1;
         }          }
 }  }
   
 bool file_write_action_under_lock(  bool file_write_action_under_lock(
                                 const String& file_spec,                                   StringPtr file_spec, 
                                 const char *action_name, void (*action)(int, void *), void *context,                                  const char* action_name, File_write_action action, void *context, 
                                 bool as_text,                                  bool as_text, 
                                 bool do_append,                                  bool do_append, 
                                 bool do_block,                                  bool do_block, 
                                 bool fail_on_lock_problem) {                                  bool fail_on_lock_problem) {
         const char *fname=file_spec.cstr(String::UL_FILE_SPEC);          CharPtr fname=file_spec->cstr(String::UL_FILE_SPEC); 
         int f;          int f;
         if(access(fname, W_OK)!=0) // no          if(access(fname, W_OK)!=0) // no
                 create_dir_for_file(file_spec);                  create_dir_for_file(file_spec); 
   
         if((f=open(fname,           if((f=open(fname, 
                 O_CREAT|O_RDWR                  O_CREAT|O_RDWR
                 |(as_text?_O_TEXT:_O_BINARY)                  |(as_text?_O_TEXT:_O_BINARY)
                 |(do_append?O_APPEND:O_TRUNC), 0664))>=0) {                  |(do_append?O_APPEND:PA_O_TRUNC), 0664))>=0) {
                 if((do_block?lock_exclusive_blocking(f):lock_exclusive_nonblocking(f))!=0) {                  if((do_block?lock_exclusive_blocking(f):lock_exclusive_nonblocking(f))!=0) {
                         Exception e("file.lock",                          Exception e("file.lock", 
                                 &file_spec,                                   file_spec, 
                                 "shared lock failed: %s (%d), actual filename '%s'",                                   "shared lock failed: %s (%d), actual filename '%s'", 
                                 strerror(errno), errno, fname);                                  strerror(errno), errno, fname); 
                         close(f);                          close(f); 
                         if(fail_on_lock_problem)                          if(fail_on_lock_problem)
                                 throw e;                                  throw e;
                         return false;                          return false;
                 }                  }
   
                 try {                  try {
                         action(f, context);                          action(f, context); 
                 } catch(...) {                  } catch(...) {
 #if O_TRUNC==0  #ifdef HAVE_FTRUNCATE
                         if(!do_append)                          if(!do_append)
                                 ftruncate(f, tell(f));                                  ftruncate(f, lseek(f, 0, SEEK_CUR)); // one can not use O_TRUNC, read lower
 #endif  #endif
                         unlock(f);                          unlock(f);close(f); 
                         close(f);  
                         /*re*/throw;                          /*re*/throw;
                 }                  }
                                   
 #if O_TRUNC==0  #ifdef HAVE_FTRUNCATE
                 if(!do_append)                  if(!do_append)
                         ftruncate(f, tell(f));                          ftruncate(f, lseek(f, 0, SEEK_CUR)); // O_TRUNC truncates even exclusevely write-locked file [thanks to Igor Milyakov <virtan@rotabanner.com> for discovering]
 #endif  #endif
                 unlock(f);                  unlock(f);close(f); 
                 close(f);  
                 return true;                  return true;
         } else          } else
                 throw Exception(errno==EACCES?"file.access":0,                  throw Exception(errno==EACCES?"file.access":0, 
                         &file_spec,                           file_spec, 
                         "%s failed: %s (%d), actual filename '%s'",                           "%s failed: %s (%d), actual filename '%s'", 
                                 action_name, strerror(errno), errno, fname);                                  action_name, strerror(errno), errno, fname); 
         // here should be nothing, see rethrow above          // here should be nothing, see rethrow above
 }  }
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
 struct File_write_action_info {  struct File_write_action_info {
         const void *data; size_t size;          const void *data; size_t size;
 };  }; 
 #endif  #endif
 static void file_write_action(int f, void *context) {  static void file_write_action(int f, void *context) {
         File_write_action_info& info=*static_cast<File_write_action_info *>(context);          File_write_action_info& info=*static_cast<File_write_action_info *>(context); 
         if(info.size) {          if(info.size) {
                 int written=write(f, info.data, info.size);                  int written=write(f, info.data, info.size); 
                 if(written<0)                  if(written<0)
                         throw Exception(0,                          throw Exception(0, 
                                 0,                                  Exception::undefined_source, 
                                 "write failed: %s (%d)",  strerror(errno), errno);                                  "write failed: %s (%d)",  strerror(errno), errno); 
         }          }
 }  }
 void file_write(  void file_write(
                                 const String& file_spec,                                   StringPtr file_spec, 
                                 const void *data, size_t size,                                   const void *data, size_t size, 
                                 bool as_text,                                  bool as_text, 
                                 bool do_append) {                                  bool do_append) {
         File_write_action_info info={data, size};          File_write_action_info info={data, size}; 
         file_write_action_under_lock(          file_write_action_under_lock(
                                 file_spec,                   file_spec, 
                                 "write", file_write_action, &info,                  "write", file_write_action, &info, 
                                 as_text,                  as_text, 
                                 do_append);                  do_append); 
 }  }
   
 // throws nothing! [this is required in file_move & file_delete]  // throws nothing! [this is required in file_move & file_delete]
 static void rmdir(const String& file_spec, size_t pos_after) {  static void rmdir(StringPtr file_spec, size_t pos_after) {
         int pos_before;          int pos_before;
         if((pos_before=file_spec.pos("/", 1, pos_after))>=0)          if((pos_before=file_spec->pos("/", 1, pos_after))>=0)
                 rmdir(file_spec, pos_before+1);                  rmdir(file_spec, pos_before+1); 
                   
         rmdir(file_spec.mid(0, pos_after-1/* / */).cstr(String::UL_FILE_SPEC));          rmdir(file_spec->mid(0, pos_after-1/* / */)->cstr(String::UL_FILE_SPEC)); 
 }  }
 bool file_delete(const String& file_spec, bool fail_on_read_problem) {  bool file_delete(StringPtr file_spec, bool fail_on_read_problem) {
         const char *fname=file_spec.cstr(String::UL_FILE_SPEC);          CharPtr fname=file_spec->cstr(String::UL_FILE_SPEC); 
         if(unlink(fname)!=0)          if(unlink(fname)!=0)
                 if(fail_on_read_problem)                  if(fail_on_read_problem)
                         throw Exception(errno==EACCES?"file.access":errno==ENOENT?"file.missing":0,                          throw Exception(errno==EACCES?"file.access":errno==ENOENT?"file.missing":0, 
                                 &file_spec,                                   file_spec, 
                                 "unlink failed: %s (%d), actual filename '%s'",                                   "unlink failed: %s (%d), actual filename '%s'", 
                                         strerror(errno), errno, fname);                                          strerror(errno), errno, fname); 
                 else                  else
                         return false;                          return false;
   
         rmdir(file_spec, 1);          rmdir(file_spec, 1); 
         return true;          return true;
 }  }
 void file_move(const String& old_spec, const String& new_spec) {  void file_move(StringPtr old_spec, StringPtr new_spec) {
         const char *old_spec_cstr=old_spec.cstr(String::UL_FILE_SPEC);          CharPtr old_spec_cstr=old_spec->cstr(String::UL_FILE_SPEC); 
         const char *new_spec_cstr=new_spec.cstr(String::UL_FILE_SPEC);          CharPtr new_spec_cstr=new_spec->cstr(String::UL_FILE_SPEC); 
                   
         create_dir_for_file(new_spec);          create_dir_for_file(new_spec); 
   
         if(rename(old_spec_cstr, new_spec_cstr)!=0)          if(rename(old_spec_cstr, new_spec_cstr)!=0)
                 throw Exception(errno==EACCES?"file.access":errno==ENOENT?"file.missing":0,                  throw Exception(errno==EACCES?"file.access":errno==ENOENT?"file.missing":0, 
                         &old_spec,                           old_spec, 
                         "rename failed: %s (%d), actual filename '%s' to '%s'",                           "rename failed: %s (%d), actual filename '%s' to '%s'", 
                                 strerror(errno), errno, old_spec_cstr, new_spec_cstr);                                  strerror(errno), errno, old_spec_cstr, new_spec_cstr); 
   
         rmdir(old_spec, 1);          rmdir(old_spec, 1); 
 }  }
   
   
 static bool entry_readable(const String& file_spec, bool need_dir) {  bool entry_exists(const char* fname, struct stat *afinfo) {
     const char *fname=file_spec.cstr(String::UL_FILE_SPEC);          struct stat lfinfo;
           bool result=stat(fname, &lfinfo)==0;
           if(afinfo)
                   *afinfo=lfinfo;
           return result;
   }
   
   bool entry_exists(StringPtr file_spec) {
           CharPtr fname=file_spec->cstr(String::UL_FILE_SPEC); 
           return entry_exists(fname, 0); 
   }
   
   static bool entry_readable(StringPtr file_spec, bool need_dir) {
       CharPtr fname=file_spec->cstr(String::UL_FILE_SPEC); 
           if(need_dir) {
                   size_t size=strlen(fname); 
                   while(size) {
                           char c=fname[size-1]; 
                           if(c=='/' || c=='\\')
                                   fname[--size]=0;
                           else
                                   break;
                   }
           }
         struct stat finfo;          struct stat finfo;
         if(access(fname, R_OK)==0 && stat(fname, &finfo)==0) {          if(access(fname, R_OK)==0 && entry_exists(fname, &finfo)) {
                 bool is_dir=(finfo.st_mode&S_IFDIR) != 0;                  bool is_dir=(finfo.st_mode&S_IFDIR) != 0;
                 return is_dir==need_dir;                  return is_dir==need_dir;
         }          }
         return false;          return false;
 }  }
 bool file_readable(const String& file_spec) {  bool file_readable(StringPtr file_spec) {
         return entry_readable(file_spec, false);          return entry_readable(file_spec, false); 
 }  }
 bool dir_readable(const String& file_spec) {  bool dir_readable(StringPtr file_spec) {
         return entry_readable(file_spec, true);          return entry_readable(file_spec, true); 
 }  }
 String *file_readable(const String& path, const String& name) {  StringPtr file_readable(StringPtr path, const String& name) {
         String *result=new(path.pool()) String(path);          StringPtr result(new String(*path));
         *result << "/";          *result << "/"; 
         *result << name;          *result << name;
         return file_readable(*result)?result:0;          return file_readable(result)?result:StringPtr(0);
 }  }
 bool file_executable(const String& file_spec) {  bool file_executable(StringPtr file_spec) {
     return access(file_spec.cstr(String::UL_FILE_SPEC), X_OK)==0;      return access(file_spec->cstr(String::UL_FILE_SPEC), X_OK)==0;
 }  }
   
 bool file_stat(const String& file_spec,   bool file_stat(StringPtr file_spec, 
                            size_t& rsize,                              size_t& rsize, 
                            time_t& ratime,                             time_t& ratime, 
                            time_t& rmtime,                             time_t& rmtime, 
                            time_t& rctime,                             time_t& rctime, 
                            bool fail_on_read_problem) {                             bool fail_on_read_problem) {
         Pool& pool=file_spec.pool();          CharPtr fname=file_spec->cstr(String::UL_FILE_SPEC); 
         const char *fname=file_spec.cstr(String::UL_FILE_SPEC);  
     struct stat finfo;      struct stat finfo;
         if(stat(fname, &finfo)!=0)          if(stat(fname, &finfo)!=0)
                 if(fail_on_read_problem)                  if(fail_on_read_problem)
                         throw Exception("file.missing",                          throw Exception("file.missing", 
                                 &file_spec,                                   file_spec, 
                                 "getting file size failed: %s (%d), real filename '%s'",                                   "getting file size failed: %s (%d), real filename '%s'", 
                                         strerror(errno), errno, fname);                                          strerror(errno), errno, fname); 
                 else                  else
                         return false;                          return false;
         rsize=finfo.st_size;          rsize=finfo.st_size;
Line 390  bool file_stat(const String& file_spec, Line 709  bool file_stat(const String& file_spec,
         return true;          return true;
 }  }
   
 char *getrow(char **row_ref, char delim) {  char* getrow(char* *row_ref, char delim) {
     char *result=*row_ref;      char* result=*row_ref;
     if(result) {      if(result) {
                 *row_ref=strchr(result, delim);                  *row_ref=strchr(result, delim); 
                 if(*row_ref)                   if(*row_ref) 
                         *((*row_ref)++)=0;                           *((*row_ref)++)=0; 
                 else if(!*result)                   else if(!*result) 
Line 402  char *getrow(char **row_ref, char delim) Line 721  char *getrow(char **row_ref, char delim)
     return result;      return result;
 }  }
   
 char *lsplit(char *string, char delim) {  char* lsplit(char* string, char delim) {
     if(string) {      if(string) {
                 char *v=strchr(string, delim);                  char* v=strchr(string, delim); 
                 if(v) {                  if(v) {
                         *v=0;                          *v=0;
                         return v+1;                          return v+1;
Line 413  char *lsplit(char *string, char delim) { Line 732  char *lsplit(char *string, char delim) {
     return 0;      return 0;
 }  }
   
 char *lsplit(char **string_ref, char delim) {  char* lsplit(char* *string_ref, char delim) {
     char *result=*string_ref;      char* result=*string_ref;
         char *next=lsplit(*string_ref, delim);          char* next=lsplit(*string_ref, delim); 
     *string_ref=next;      *string_ref=next;
     return result;      return result;
 }  }
   
 char *rsplit(char *string, char delim) {  char* rsplit(char* string, char delim) {
     if(string) {      if(string) {
                 char *v=strrchr(string, delim);                  char* v=strrchr(string, delim); 
                 if(v) {                  if(v) {
                         *v=0;                          *v=0;
                         return v+1;                          return v+1;
Line 432  char *rsplit(char *string, char delim) { Line 751  char *rsplit(char *string, char delim) {
 }  }
   
 /// @todo less stupid type detection  /// @todo less stupid type detection
 char *format(Pool& pool, double value, char *fmt) {  const char *format(Pool& pool, double value, char* fmt) {
         char local_buf[MAX_NUMBER];          char local_buf[MAX_NUMBER]; 
         size_t size;          size_t size;
                   
         if(fmt)          if(fmt)
                 if(strpbrk(fmt, "diouxX"))                  if(strpbrk(fmt, "diouxX"))
                         if(strpbrk(fmt, "ouxX"))                          if(strpbrk(fmt, "ouxX"))
                                 size=snprintf(local_buf, sizeof(local_buf), fmt, (uint)value);                                  size=snprintf(local_buf, sizeof(local_buf), fmt, (uint)value); 
                         else                          else
                                 size=snprintf(local_buf, sizeof(local_buf), fmt, (int)value);                                  size=snprintf(local_buf, sizeof(local_buf), fmt, (int)value); 
                 else                  else
                         size=snprintf(local_buf, sizeof(local_buf), fmt, value);                          size=snprintf(local_buf, sizeof(local_buf), fmt, value); 
         else          else
                 size=snprintf(local_buf, sizeof(local_buf), "%d", (int)value);                  size=snprintf(local_buf, sizeof(local_buf), "%d", (int)value); 
                   
         char *pool_buf=(char *)pool.malloc(size+1, 4);          return pool.copy(local_buf, size+1); 
         memcpy(pool_buf, local_buf, size+1);  
         return pool_buf;  
 }  }
   
 size_t stdout_write(const void *buf, size_t size) {  size_t stdout_write(const void *buf, size_t size) {
 #ifdef WIN32  #ifdef WIN32
         do{          do{
                 int chunk_written=fwrite(buf, 1, min(8*0x400, size), stdout);                  int chunk_written=fwrite(buf, 1, min(8*0x400, size), stdout); 
                 if(chunk_written<=0)                  if(chunk_written<=0)
                         break;                          break;
                 size-=chunk_written;                  size-=chunk_written;
                 buf=((const char*)buf)+chunk_written;                  buf=((const char*)buf)+chunk_written;
         } while(size>0);          } while(size>0); 
   
         return size;          return size;
 #else  #else
         return fwrite(buf, 1, size, stdout);          return fwrite(buf, 1, size, stdout); 
 #endif  #endif
 }  }
   
 char *unescape_chars(Pool& pool, const char *cp, int len) {  char* unescape_chars(Pool& pool, const char* cp, int len) {
         char *s=(char *)pool.malloc(len + 1, 5);          char* s=pool.malloc(len + 1); 
         enum EscapeState {          enum EscapeState {
                 EscapeRest,                   EscapeRest, 
                 EscapeFirst,                   EscapeFirst, 
Line 479  char *unescape_chars(Pool& pool, const c Line 796  char *unescape_chars(Pool& pool, const c
         int srcPos=0;          int srcPos=0;
         int dstPos=0;          int dstPos=0;
         while(srcPos < len) {          while(srcPos < len) {
                 int ch=cp[srcPos];                  int ch=cp[srcPos]; 
                 switch(escapeState) {                  switch(escapeState) {
                         case EscapeRest:                          case EscapeRest:
                         if(ch=='%') {                          if(ch=='%') {
                                 escapeState=EscapeFirst;                                  escapeState=EscapeFirst;
                         } else if(ch=='+') {                          } else if(ch=='+') {
                                 s[dstPos++]=' ';                                  s[dstPos++]=' '; 
                         } else {                          } else {
                                 s[dstPos++]=ch;                                   s[dstPos++]=ch; 
                         }                          }
Line 495  char *unescape_chars(Pool& pool, const c Line 812  char *unescape_chars(Pool& pool, const c
                         escapeState=EscapeSecond;                          escapeState=EscapeSecond;
                         break;                          break;
                         case EscapeSecond:                          case EscapeSecond:
                         escapedValue +=hex_value[ch];                          escapedValue +=hex_value[ch]; 
                         s[dstPos++]=escapedValue;                          s[dstPos++]=escapedValue;
                         escapeState=EscapeRest;                          escapeState=EscapeRest;
                         break;                          break;
                 }                  }
                 srcPos++;                  srcPos++; 
         }          }
         s[dstPos]=0;          s[dstPos]=0;
         return s;          return s;
 }  }
   
 /// used by attributed_meaning_to_string / append_attribute_subattribute  
 struct Attributed_meaning_info {  
         String *header; // header line being constructed  
         String::Untaint_lang lang; // language in which to append to that line  
 };  
 static void append_attribute_subattribute(const Hash::Key& akey, Hash::Val *avalue,   
                                                                                   void *info) {  
         if(akey==VALUE_NAME)  
                 return;  
   
         Attributed_meaning_info& ami=*static_cast<Attributed_meaning_info *>(info);  
   
         // ...; charset=windows1251  
         *ami.header << "; ";  
         ami.header->append(akey, ami.lang);  
         *ami.header << "=";  
         ami.header->append(static_cast<Value *>(avalue)->as_string(), ami.lang);  
 }  
 const String& attributed_meaning_to_string(Value& meaning,   
                                                                                    String::Untaint_lang lang) {  
         String &result=*new(meaning.pool()) String(meaning.pool());  
         if(Hash *hash=meaning.get_hash(0)) {  
                 // $value(value) $subattribute(subattribute value)  
                 if(Value *value=static_cast<Value *>(hash->get(*value_name)))  
                         result.append(value->as_string(), lang, true);  
   
                 Attributed_meaning_info attributed_meaning_info={  
                         &result,  
                         lang  
                 };  
                 hash->for_each(append_attribute_subattribute, &attributed_meaning_info);  
         } else // result value  
                 result.append(meaning.as_string(), lang, true);  
   
         return result;  
 }  
   
 #ifdef WIN32  #ifdef WIN32
 void back_slashes_to_slashes(char *s) {  void back_slashes_to_slashes(char* s) {
         if(s)          if(s)
                 for(; *s; s++)                  for(; *s; s++)
                         if(*s=='\\')                          if(*s=='\\')
                                 *s='/';                                  *s='/'; 
 }  }
 /*  /*
 void slashes_to_back_slashes(char *s) {  void slashes_to_back_slashes(char* s) {
         if(s)          if(s)
                 for(; *s; s++)                  for(; *s; s++)
                         if(*s=='/')                          if(*s=='/')
                                 *s='\\';                                  *s='\\'; 
 }  }
 */  */
 #endif  #endif
   
 bool StrEqNc(const char *s1, const char *s2, bool strict) {  bool StrEqNc(const char* s1, const char* s2, bool strict) {
         while(true) {          while(true) {
                 if(!(*s1)) {                  if(!(*s1)) {
                         if(!(*s2))                          if(!(*s2))
Line 574  bool StrEqNc(const char *s1, const char Line 854  bool StrEqNc(const char *s1, const char
                                 return false;                                  return false;
                 } else if((*s1) !=(*s2))                  } else if((*s1) !=(*s2))
                         return false;                          return false;
                 s1++;                  s1++; 
                 s2++;                  s2++; 
         }          }
 }  }
   
 static bool isLeap(int year) {  static bool isLeap(int year) {
     return !(      return !(
              (year % 4) || ((year % 400) && !(year % 100))               (year % 4) || ((year % 400) && !(year % 100))
             );              ); 
 }  }
   
 int getMonthDays(int year, int month) {  int getMonthDays(int year, int month) {
     int monthDays[]={      int monthDays[]={
         31,          31, 
         isLeap(year) ? 29 : 28,          isLeap(year) ? 29 : 28, 
         31,          31, 
         30,          30, 
         31,          31, 
         30,          30, 
         31,          31, 
         31,          31, 
         30,          30, 
         31,          31, 
         30,          30, 
         31          31
     };      }; 
     return monthDays[month];      return monthDays[month]; 
 }  }
   
 void remove_crlf(char *start, char *end) {  void remove_crlf(char* start, char* end) {
         for(char *p=start; p<end; p++)          for(char* p=start; p<end; p++)
                 switch(*p) {                  switch(*p) {
                         case '\n': *p='|'; break;                          case '\n': *p='|';  break;
                         case '\r': *p=' '; break;                          case '\r': *p=' ';  break;
                 }                  }
 }  }
   
   
 /// must be last in this file  /// must be last in this file
 #undef vsnprintf  #undef vsnprintf
 int __vsnprintf(char *b, size_t s, const char *f, va_list l) {  int __vsnprintf(char* b, size_t s, const char* f, va_list l) {
         if(!s)          if(!s)
                 return 0;                  return 0;
   
Line 629  int __vsnprintf(char *b, size_t s, const Line 909  int __vsnprintf(char *b, size_t s, const
   
           if the number of bytes to write exceeds buffer, then count bytes are written and –1 is returned            if the number of bytes to write exceeds buffer, then count bytes are written and –1 is returned
         */          */
         r=_vsnprintf(b, s, f, l);          r=_vsnprintf(b, s, f, l); 
         if(r<0)           if(r<0) 
                 r=s;                  r=s;
 #else  #else
         r=vsnprintf(b, s, f, l);          r=vsnprintf(b, s, f, l); 
         /*          /*
         solaris:           solaris: 
         man vsnprintf          man vsnprintf
Line 654  int __vsnprintf(char *b, size_t s, const Line 934  int __vsnprintf(char *b, size_t s, const
         return r;          return r;
 }  }
   
 int __snprintf(char *b, size_t s, const char *f, ...) {  int __snprintf(char* b, size_t s, const char* f, ...) {
         va_list l;          va_list l;
     va_start(l, f);      va_start(l, f); 
     int r=__vsnprintf(b, s, f, l);      int r=__vsnprintf(b, s, f, l); 
     va_end(l);      va_end(l); 
         return r;          return r;
 }  }
   
 int pa_sleep(unsigned long secs, unsigned long usecs) {  int pa_sleep(unsigned long secs, unsigned long usecs) {
         for (; usecs >= 1000000; ++secs, usecs -= 1000000);          for (;  usecs >= 1000000; ++secs, usecs -= 1000000); 
   
 #ifdef WIN32  #ifdef WIN32
         Sleep(secs * 1000 + usecs / 1000);          Sleep(secs * 1000 + usecs / 1000); 
         return 0;          return 0;
 #else  #else
         struct timeval t;          struct timeval t;
         t.tv_sec = secs;          t.tv_sec = secs;
         t.tv_usec = usecs;          t.tv_usec = usecs;
         return (select(0, NULL, NULL, NULL, &t) == -1 ? errno : 0);          return (select(0, NULL, NULL, NULL, &t) == -1 ? errno : 0); 
 #endif  #endif
 }  }
   
   
Removed from v.1.116  
changed lines
  Added in v.1.143.2.9

E-mail: