src/server/os.cxx

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by www.databasecache.com                           *
   3  *   Contact: praba_tuty@databasecache.com                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15   ***************************************************************************/
  16 #include <os.h>
  17 #include <Debug.h>
  18
  19 caddr_t os::mmap(caddr_t addr, size_t len, int prot, int flags, int fildes, off_t off)
  20 {
  21     return ((caddr_t)::mmap(addr,len,prot,flags,fildes,off));
  22 }
  23
  24 int os::munmap(caddr_t addr, size_t len)
  25 {
  26     return ::munmap(addr, len);
  27 }
  28
  29
  30 shared_memory_id os::shm_create(shared_memory_key key, size_t size, int flag)
  31 {
  32     return ::shmget(key, size, IPC_CREAT | IPC_EXCL | flag);
  33     //return ::shmget(key, size, IPC_CREAT | flag);
  34 }
  35
  36 shared_memory_id os::shm_open(shared_memory_key key, size_t size, int flag)
  37 {
  38     return ::shmget(key, size, flag);
  39 }
  40 int os::shmctl(int shmid, int cmd)
  41 {
  42     return ::shmctl(shmid, cmd, NULL);
  43 }
  44
  45 void*  os::shm_attach(shared_memory_id id, const void *ptr, int flag)
  46 {
  47     return ::shmat(id, ptr, flag);
  48 }
  49
  50 int os::shm_detach (void* addr)
  51 {
  52     return ::shmdt((char*)addr);
  53 }
  54
  55 double os::floor(double val)
  56 {
  57     return ::floor(val);
  58 }
  59
  60 int os::gettimeofday(struct timeval *tp)
  61 {
  62     int retval;
  63     retval=::gettimeofday(tp, NULL);
  64     return retval;
  65 }
  66
  67 struct tm* os::localtime(long *secs)
  68 {
  69     return ::localtime(secs);
  70 }
  71
  72 pid_t os::getpid()
  73 {
  74     return ::getpid();
  75 }
  76 pthread_t os::getthrid()
  77 {
  78     return ::pthread_self();
  79 }
  80
  81
  82
  83
  84 int os::openFile(const char *name, FileOpenMode flags, size_t size)
  85 {
  86     int retval = -1;
  87     //mode_t mode = S_IRWXU | S_IRGRP | S_IWGRP ;
  88     mode_t mode = (mode_t)0755 ;
  89     retval=::open(name, flags, mode);
  90     if (0 == size)
  91         return retval;
  92     os::lseek(retval, size-1, SEEK_SET);
  93     char *buf = (char*)" ";
  94     os::write(retval, buf, 1);
  95     return retval;
  96 }
  97
  98 int os::closeFile(int fd)
  99 {
 100     return ::close(fd);
 101 }
 102
 103 off_t os::lseek(int fildes, off_t offset, int whence)
 104 {
 105     return ::lseek(fildes, offset, whence);
 106 }
 107
 108 size_t os::write(int fildes, char *buf, size_t size)
 109 {
 110     return ::write(fildes, buf, size);
 111 }
 112
 113 int os::msync(caddr_t addr, size_t len, int flags)
 114 {
 115     return ::msync(addr, len, flags);
 116 }
 117 int os::fsync(int fildes)
 118 {
 119     return ::fsync(fildes);
 120 }
 121
 122 char* os::encrypt(const char *key, const char *salt)
 123 {
 124     return ::crypt(key, salt);
 125 }
 126
 127 void* os::memset(void *src, int c, size_t size)
 128 {
 129     return::memset(src, c, size);
 130 }
 131
 132 void* os::memcpy(void *src, const void *dest, size_t size)
 133 {
 134     return ::memcpy(src, dest, size);
 135 }
 136
 137 int os::memcmp(const void *s1, const void *s2, size_t size)
 138 {
 139     return ::memcmp(s1, s2, size);
 140 }
 141 sighandler_t os::signal(int signum, sighandler_t handler)
 142 {
 143     return ::signal(signum, handler);
 144 }
 145
 146 size_t os::alignLong(size_t size)
 147 {
 148     return ((size - 1) | (sizeof(long) - 1)) + 1;
 149 }
 150
 151 size_t os::align(size_t size)
 152 {
 153     //Calls alignLong
 154     return ((size - 1) | (sizeof(long) - 1)) + 1;
 155 }
 156
 157 int os::select(int nfds, fd_set *readfds, fd_set *writefds,
 158                  fd_set *exceptfds, struct timeval * timeout)
 159 {
 160     return ::select(nfds, readfds, writefds, exceptfds, timeout);
 161 }
 162
 163
 164 char* os::getenv(const char *envVarName)
 165 {
 166     char *retVal;
 167     retVal = ::getenv(envVarName);
 168     return retVal;
 169 }
 170
 171 int os::setenv(const char *envVarName, const char *value)
 172 {
 173     return ::setenv(envVarName, value,1);
 174 }
 175
 176 int os::kill(pid_t pid, int sig)
 177 {
 178     return ::kill(pid, sig);
 179 }
 180 bool os::atobool(char *value)
 181 {
 182     if (strlen(value) ==3 && strncasecmp(value,"YES",3)==0) return true;
 183     else if (strlen(value) ==2 && strncasecmp(value,"NO", 2)==0) return false;
 184     else if (strlen(value) ==4 && strncasecmp(value,"true",4)==0) return true;
 185     else if (strlen(value) ==5 && strncasecmp(value,"false",5)==0) return false;
 186     return false;
 187 }
 188 pid_t os::createProcess(const char* cmdName, const char *arg0, ...)
 189 {
 190     pid_t pid;
 191     pid = ::vfork();
 192     if (pid == (pid_t) -1 )
 193     {
 194         printf("Process creation failed\n");
 195         return -1;
 196     }
 197     if (pid >0)
 198     {
 199         //return for parent
 200         return pid;
 201     }
 202     va_list ap;
 203     va_start(ap,arg0);
 204
 205     const char *argv[5];
 206
 207     argv[0]=cmdName;
 208     argv[1]=arg0;
 209
 210     argv[2]=NULL;
 211     int i = 2;
 212     while(argv[i++]=va_arg(ap,char *));
 213     switch(i){
 214         case 2:
 215             pid=::execl(argv[0],argv[1]);break;
 216         case 3:
 217             pid=::execl(argv[0],argv[1],argv[2]);break;
 218         case 4:
 219             pid=::execl(argv[0],argv[1],argv[2],argv[3]);break;
 220         case 5:
 221             pid=::execl(argv[0],argv[1],argv[2],argv[3],argv[4]);break;
 222         default:
 223             printf("only three options allowed\n");
 224             pid=-1;break;
 225     }
 226     if (pid < 0)
 227         printf("Exec failed\n");
 228     return pid;
 229
 230 }
 231 pid_t os::fork()
 232 {
 233     return ::fork();
 234 }
 235 size_t os::send(int fd, const void *buf, size_t len, int flags)
 236 {
 237     return ::send(fd, buf, len, flags);
 238 }
 239 size_t os::recv(int fd, void *buf, size_t len, int flags)
 240 {
 241     return ::recv(fd, buf, len, flags);
 242 }