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

Diff for /parser3/src/include/pa_common.h between versions 1.55 and 1.187

version 1.55, 2001/10/24 16:33:02 version 1.187, 2020/12/09 12:37:05
Line 1 Line 1
 /** @file  /** @file
         Parser: commonly used functions.          Parser: commonly used functions.
   
         Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001-2017 Art. Lebedev Studio (http://www.artlebedev.com)
         Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
   
         $Id$  
 */  */
   
 #ifndef PA_COMMON_H  #ifndef PA_COMMON_H
 #define PA_COMMON_H  #define PA_COMMON_H
   
 #include "pa_config_includes.h"  #define IDENT_PA_COMMON_H "$Id$"
 #include "pa_pool.h"  
 #include "pa_string.h"  #include "pa_string.h"
   #include "pa_hash.h"
   
 class Value;  class Request;
   
 #if _MSC_VER  // defines
   #define HTTP_STATUS             "status"
   #define HTTP_STATUS_CAPITALIZED "Status"
   
 #ifndef open  #define HTTP_CONTENT_LENGTH             "content-length"
 #       define open _open  
 #endif  
 #ifndef close  
 #       define close _close  
 #endif  
 #ifndef read  
 #       define read _read  
 #endif  
 #ifndef write  
 #       define write _write  
 #endif  
 #ifndef stat  
 #       define stat _stat  
 #endif  
 #ifndef lseek  
 #       define lseek _lseek  
 #endif  
   
 #ifndef vsnprintf  #define HTTP_CONTENT_TYPE               "content-type"
 int __vsnprintf(char *, size_t, const char *, va_list);  #define HTTP_CONTENT_TYPE_UPPER         "CONTENT-TYPE"
 #       define vsnprintf __vsnprintf   #define HTTP_CONTENT_TYPE_CAPITALIZED   "Content-Type"
 #endif  
 #ifndef snprintf  #define CONTENT_DISPOSITION             "content-disposition"
 int __snprintf(char *, size_t, const char *, ...);  #define CONTENT_DISPOSITION_UPPER       "CONTENT-DISPOSITION"
 #       define snprintf __snprintf  #define CONTENT_DISPOSITION_CAPITALIZED "Content-Disposition"
   
   #define CONTENT_DISPOSITION_ATTACHMENT  "attachment"
   #define CONTENT_DISPOSITION_INLINE      "inline"
   #define CONTENT_DISPOSITION_FILENAME_NAME "filename"
   
   #define HTTP_CONTENT_TYPE_FORM_URLENCODED       "application/x-www-form-urlencoded"
   #define HTTP_CONTENT_TYPE_MULTIPART_FORMDATA    "multipart/form-data"
   #define HTTP_CONTENT_TYPE_MULTIPART_RELATED     "multipart/related"
   #define HTTP_CONTENT_TYPE_MULTIPART_MIXED       "multipart/mixed"
   
   const String content_disposition_filename_name(CONTENT_DISPOSITION_FILENAME_NAME);
   
   #define HASH_ORDER
   
   #ifdef HASH_ORDER
   #undef PA_HASH_CLASS
   #include "pa_hash.h"
 #endif  #endif
   
   class Value;
   typedef HASH_STRING<Value*> HashStringValue;
   
   // replace system s*nprintf with our versions
   #undef vsnprintf 
   int pa_vsnprintf(char *, size_t, const char* , va_list);
   #define vsnprintf pa_vsnprintf 
   #undef snprintf
   int pa_snprintf(char *, size_t, const char* , ...);
   #define snprintf pa_snprintf
   
   #ifdef _MSC_VER
   
 //access  //access
 #define F_OK 0  #define F_OK 0
 #define X_OK 1  #define X_OK 1
Line 55  int __snprintf(char *, size_t, const cha Line 69  int __snprintf(char *, size_t, const cha
 #ifndef strcasecmp  #ifndef strcasecmp
 #       define strcasecmp _stricmp  #       define strcasecmp _stricmp
 #endif  #endif
   
 #ifndef strncasecmp  #ifndef strncasecmp
 #       define strncasecmp _strnicmp  #       define strncasecmp _strnicmp
 #endif  #endif
 #ifndef mkdir  
 #       define mkdir(path, mode) _mkdir(path)  
 #endif  
   
 #ifndef putenv  #define stat __stat64
 #       define putenv _putenv  #define pa_fstat _fstat64
 #endif  
   int pa_stat(const char *pathname, struct stat *buffer);
   int pa_open(const char *pathname, int flags, int mode=0);
   FILE *pa_fopen(const char *pathname, const char *mode);
   
   #define pa_lseek _lseeki64
   
   #else
   
   #define pa_stat stat
   #define pa_fstat fstat
   
   #define pa_open open
   #define pa_fopen fopen
   
   #define pa_lseek lseek
   
 #endif  #endif
   
 /** under WIN32 "t" mode fixes DOS chars OK,   /** 
         can't say that about other systems/ line break styles          file related functions
   */
   
   #define FILE_BUFFER_SIZE        4096
   
   int pa_lock_shared_blocking(int fd);
   int pa_lock_exclusive_blocking(int fd);
   int pa_lock_exclusive_nonblocking(int fd);
   int pa_unlock(int fd);
   
   void create_dir_for_file(const String& file_spec);
   
   int pa_get_valid_file_options_count(HashStringValue& options);
   
   typedef void (*File_read_action)(struct stat& finfo, int f, const String& file_spec, void *context);
   
   /**
           shared-lock specified file, 
           do actions under lock.
           if fail_on_read_problem is true[default] throws an exception
           
           @returns true if read OK
   */
   bool file_read_action_under_lock(const String& file_spec, 
                                   const char* action_name, File_read_action action, void *context,
                                   bool as_text=false,
                                   bool fail_on_read_problem=true);
   
   /**
           read specified text file
           if fail_on_read_problem is true[default] throws an exception
   
           WARNING: charset is used for http header case conversion, it's not a charset of input file!
 */  */
 void fix_line_breaks(char *src, size_t& size);  char *file_read_text(Request_charsets& charsets, const String& file_spec, bool fail_on_read_problem = true);
   char *file_load_text(Request& r, const String& file_spec, bool fail_on_read_problem = true, HashStringValue* options = 0, bool transcode_result = true);
   
   struct File_read_result {
           bool success;
           char* str; size_t length;
           HashStringValue* headers;
   };
   
 /**  /**
         read specified text file using pool,           read specified binary file
         if fail_on_read_problem is true[default] throws an exception          if fail_on_read_problem is true[default] throws an exception
 */  */
 char *file_read_text(Pool& pool,   
                                          const String& file_spec,   File_read_result file_read_binary(const String& file_spec, bool fail_on_read_problem = true, char* buf = 0, uint64_t offset = 0, size_t limit = 0);
                                          bool fail_on_read_problem=true);  
   
 /**  /**
         read specified file using pool,           load specified file
         if fail_on_read_problem is true[default] throws an exception          if fail_on_read_problem is true[default] throws an exception
 */  */
 bool file_read(Pool& pool, const String& file_spec,   
                            void*& data, size_t& size,   File_read_result file_load(Request& r, const String& file_spec, bool as_text, HashStringValue* options=0, bool fail_on_read_problem=true, bool transcode_text_result=true);
                            bool as_text,  
                            bool fail_on_read_problem=true,  typedef void (*File_write_action)(int f, void *context);
                            size_t offset=0, size_t limit=0);  
   
 /**  /**
         write data to specified file using pool,           lock specified file exclusively, 
           do actions under lock.
         throws an exception in case of problems          throws an exception in case of problems
           
           if block=false does non-blocking lock
           @returns true if locked OK, or false if non-blocking locking failed
 */  */
 void file_write(Pool& pool,   bool file_write_action_under_lock(
                                   const String& file_spec, 
                                   const char* action_name,
                                   File_write_action action,
                                   void *context,
                                   bool as_text=false,
                                   bool do_append=false,
                                   bool do_block=true,
                                   bool fail_on_lock_problem=true);
   
   /**
           write data to specified file, 
           throws an exception in case of problems
   */
   void file_write(
                                   Request_charsets& charsets,
                                 const String& file_spec,                                  const String& file_spec,
                                 const void *data, size_t size,                                   const char* data,
                                 bool as_text/*,                                  size_t size, 
                                 bool exclusive=false*/);                                  bool as_text,
                                   bool do_append=false,
                                   Charset* asked_charset=0);
   
 /**  /**
         delete specified file           delete specified file 
         throws an exception in case of problems          throws an exception in case of problems
 */  */
 void file_delete(Pool& pool, const String& file_spec);  bool file_delete(const String& file_spec, bool fail_on_problem=true, bool keep_empty_dirs=false);
 /**  /**
         move specified file           move specified file 
         throws an exception in case of problems          throws an exception in case of problems
 */  */
 void file_move(Pool& pool, const String& old_spec, const String& new_spec);  void file_move(const String& old_spec, const String& new_spec, bool keep_empty_dirs=false);
   
 bool file_readable(const String& file_spec);  bool entry_exists(const char* fname, struct stat *afinfo=0);
 bool dir_readable(const String& file_spec);  bool entry_exists(const String& file_spec);
 String *file_readable(const String& path, const String& name);  bool file_exist(const String& file_spec);
   bool dir_exists(const String& file_spec);
   const String* file_exist(const String& path, const String& name);
 bool file_executable(const String& file_spec);  bool file_executable(const String& file_spec);
   
 bool file_stat(const String& file_spec,   bool file_stat(const String& file_spec, uint64_t& rsize, time_t& ratime, time_t& rmtime, time_t& rctime, bool fail_on_read_problem=true);
                            size_t& rsize,   size_t check_file_size(uint64_t size, const String* file_spec);
                            time_t& ratime,  
                            time_t& rmtime,  
                            time_t& rctime,  
                            bool fail_on_read_problem=true);  
   
 /**  size_t stdout_write(const void *buf, size_t size);
         scans for @a delim[default \n] in @a *row_ref,   
         @return piece of line before it or end of string, if no @a delim found  void check_safe_mode(struct stat finfo, const String& file_spec, const char* fname); 
         assigns @a *row_ref to point right after delimiter if there were one  
         or to zero if no @a delim were found.  ssize_t file_block_read(const int f, void* buffer, const size_t size);
   
   /** 
           String related functions
 */  */
   
   /** under WIN32 "t" mode fixes DOS chars OK, 
           can't say that about other systems/ line break styles
   */
   void fix_line_breaks(char *str, size_t& length /* < may change! used to speedup next actions */);
   
 char *getrow(char **row_ref,char delim='\n');  char *getrow(char **row_ref,char delim='\n');
 //char *lsplit(char *string, char delim);  char *lsplit(char *string, char delim);
 char *lsplit(char **string_ref,char delim);  char *lsplit(char **string_ref,char delim);
 char *rsplit(char *string, char delim);  char *rsplit(char *string, char delim);
 char *format(Pool& pool, double value, char *fmt);  
   
 #ifndef max  const char* format(double value, const char *fmt);
 inline int max(int a,int b) { return a>b?a:b; }  
 inline int min(int a,int b){ return a<b?a:b; }  
 #endif  
   
 size_t stdout_write(const void *buf, size_t size);  char* unescape_chars(const char* cp, int len, Charset* client_charset=0, bool js=false/*true==decode \uXXXX and don't convert '+' to space*/);
   
 char *unescape_chars(Pool& pool, const char *cp, int len);  char *search_stop(char*& current, char cstop_at);
   
 /**  inline int pa_strncasecmp(const char* str, const char* substr, size_t count=0) {
         $content-type[text/html] ->           return strncasecmp(str, substr, count ? count : strlen(substr));
                 content-type: text/html  }
         $content-type[$value[text/html] charset[windows-1251]] ->   
                 content-type: text/html; charset=windows-1251  
 */  
 const String& attributed_meaning_to_string(Value& meaning, String::Untaint_lang lang);  
   
 #ifdef WIN32  #ifdef WIN32
 void back_slashes_to_slashes(char *s);  void back_slashes_to_slashes(char *s);
 //void slashes_to_back_slashes(char *s);  
 #endif  #endif
   
 #ifndef _qsort  size_t strpos(const char *str, const char *substr);
 #       define _qsort(names,cnt,sizeof_names,func_addr) \  
                 qsort(names,cnt,sizeof_names,func_addr)  int remove_crlf(char *start, char *end);
 #endif  
   inline bool pa_isalpha(unsigned char c) { return (((c>='A') && (c<='Z')) || ((c>='a') && (c<='z'))); }
   inline bool pa_isalnum(unsigned char c) { return (((c>='0') && (c<='9')) || pa_isalpha(c)); }
   
   char *pa_strcat(const char *a, const char *b, const char *c = 0);
   const char *pa_filename(const char *path);
   
 bool StrEqNc(const char *s1, const char *s2, bool strict=true);  const char* capitalize(const char* s);
   char *str_lower(const char *s, size_t helper_length=0);
   char *str_upper(const char *s, size_t helper_length=0);
   
   const char* hex_string(unsigned char* bytes, size_t size, bool upcase);
   extern const char* hex_digits;
   
   const char *pa_idna_encode(const char *in, Charset &source);
   const char *pa_idna_decode(const char *in, Charset &source);
   
   unsigned long pa_crc32(const char *in, size_t in_size);
   unsigned long pa_crc32(const String& file_spec);
   
   /** 
           Mix functions
   */
   
 #define SECS_PER_DAY (60*60*24)  #define PA_DEFAULT(A,B) ((A) ? (A):(B) )
 int getMonthDays(int year, int month);  
   
 void remove_crlf(char *start, char *end);  Charset* detect_charset(const char* content_type);
   
   // globals
   
   extern const String file_status_name;
   
   // global defines for file options which are handled but not checked elsewhere, we check them
   
   #define PA_COLUMN_SEPARATOR_NAME "separator"
   #define PA_COLUMN_ENCLOSER_NAME "encloser"
   #define PA_CHARSET_NAME "charset"
   #define PA_RESPONSE_CHARSET_NAME "response-charset"
   
   // globals defines for sql options
   
   #define SQL_BIND_NAME "bind"
   #define PA_SQL_LIMIT_NAME "limit"
   #define PA_SQL_OFFSET_NAME "offset"
   #define SQL_DEFAULT_NAME "default"
   #define SQL_DISTINCT_NAME "distinct"
   #define SQL_VALUE_TYPE_NAME "type"
   
   extern String sql_bind_name;
   extern String sql_limit_name;
   extern String sql_offset_name;
   extern String sql_default_name;
   extern String sql_distinct_name;
   extern String sql_value_type_name;
   
   #ifndef DOXYGEN
   enum Table2hash_distint { D_ILLEGAL, D_FIRST };
   enum Table2hash_value_type { C_HASH, C_STRING, C_TABLE, C_CODE };
 #endif  #endif
   
   #endif
   
Removed from v.1.55  
changed lines
  Added in v.1.187

E-mail: