src/storage/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 void* os::mmap(void* addr, size_t len, int prot, int flags, int fildes, off_t off)
  20 {
  21 #ifdef SOLARIS
  22     return ((void*)::mmap((char*)addr,len,prot,flags,fildes,off));
  23 #else
  24     return ((void*)::mmap(addr,len,prot,flags,fildes,off));
  25 #endif
  26 }
  27
  28 int os::munmap(caddr_t addr, size_t len)
  29 {
  30     return ::munmap(addr, len);
  31 }
  32
  33 int os::atexit(void (*exitHndlr)(void))
  34 {
  35     return ::atexit(exitHndlr);
  36 }
  37
  38 shared_memory_id os::shm_create(shared_memory_key key, size_t size, int flag)
  39 {
  40     return ::shmget(key, size, IPC_CREAT | IPC_EXCL | flag);
  41     //return ::shmget(key, size, IPC_CREAT | flag);
  42 }
  43
  44 shared_memory_id os::shm_open(shared_memory_key key, size_t size, int flag)
  45 {
  46     return ::shmget(key, size, flag);
  47 }
  48 int os::shmctl(int shmid, int cmd)
  49 {
  50     return ::shmctl(shmid, cmd, NULL);
  51 }
  52
  53 void*  os::shm_attach(shared_memory_id id, const void *ptr, int flag)
  54 {
  55     return ::shmat(id, ptr, flag);
  56 }
  57
  58 int os::shm_detach (void* addr)
  59 {
  60     return ::shmdt((char*)addr);
  61 }
  62
  63 int os::gettimeofday(struct timeval *tp)
  64 {
  65     int retval;
  66     retval=::gettimeofday(tp, NULL);
  67     return retval;
  68 }
  69
  70 struct tm* os::localtime(long *secs)
  71 {
  72 #ifdef SOLARIS
  73     return (struct tm*) ::localtime(secs);
  74 #else
  75     return ::localtime(secs);
  76 #endif
  77 }
  78
  79 int os::openFile(const char *name, FileOpenMode flags, size_t size)
  80 {
  81     int retval = -1;
  82     //mode_t mode = S_IRWXU | S_IRGRP | S_IWGRP ;
  83     mode_t oldMode = umask(0000);
  84     mode_t mode = (mode_t)0644 ;
  85     retval=::open(name, flags, mode);
  86     umask(oldMode);
  87     if (0 == size)
  88         return retval;
  89     os::lseek(retval, size-1, SEEK_SET);
  90     char *buf = (char*)" ";
  91     os::write(retval, buf, 1);
  92     return retval;
  93 }
  94 int os::openFileForAppend(const char *name, int flag)
  95 {
  96     mode_t mode = (mode_t)0644 ;
  97     int flags = flag | O_WRONLY|O_APPEND;
  98     return  ::open(name, flags, mode);
  99 }
 100
 101 int os::closeFile(int fd)
 102 {
 103     return ::close(fd);
 104 }
 105 int os::lockFile(int fd)
 106 {
 107 #ifdef SOLARIS
 108     //TODO
 109     return 0;
 110 #else
 111     return flock(fd, LOCK_EX);
 112 #endif
 113 }
 114 int os::unlockFile(int fd)
 115 {
 116 #ifdef SOLARIS
 117     //TODO
 118     return 0;
 119 #else
 120     return ::flock(fd, LOCK_UN);
 121 #endif
 122 }
 123
 124 off_t os::lseek(int fildes, off_t offset, int whence)
 125 {
 126     return ::lseek(fildes, offset, whence);
 127 }
 128
 129 size_t os::write(int fildes, char *buf, size_t size)
 130 {
 131     return ::write(fildes, buf, size);
 132 }
 133
 134 int os::msync(caddr_t addr, size_t len, int flags)
 135 {
 136     return ::msync(addr, len, flags);
 137 }
 138 int os::fsync(int fildes)
 139 {
 140     return ::fsync(fildes);
 141 }
 142
 143 char* os::encrypt(const char *key, const char *salt)
 144 {
 145     return ::crypt(key, salt);
 146 }
 147
 148 void* os::memset(void *src, int c, size_t size)
 149 {
 150     return::memset(src, c, size);
 151 }
 152
 153 void* os::memcpy(void *src, const void *dest, size_t size)
 154 {
 155     return ::memcpy(src, dest, size);
 156 }
 157
 158 int os::memcmp(const void *s1, const void *s2, size_t size)
 159 {
 160     return ::memcmp(s1, s2, size);
 161 }
 162 sighandler_t os::signal(int signum, sighandler_t handler)
 163 {
 164     return ::signal(signum, handler);
 165 }
 166
 167 int os::select(int nfds, fd_set *readfds, fd_set *writefds,
 168                  fd_set *exceptfds, struct timeval * timeout)
 169 {
 170     return ::select(nfds, readfds, writefds, exceptfds, timeout);
 171 }
 172 int os::sleep(int secs)
 173 {
 174     return ::sleep(secs);
 175 }
 176 int os::usleep(int msecs)
 177 {
 178     struct timeval timeout;
 179     timeout.tv_sec = 0;
 180     timeout.tv_usec = msecs;
 181     os::select(0,0,0,0, &timeout);
 182     return 0;
 183 }
 184 int os::getFileSize(const char *fileName)
 185 {
 186     struct stat buf;
 187     stat(fileName, &buf);
 188     return buf.st_size;
 189 }
 190
 191 char* os::getenv(const char *envVarName)
 192 {
 193     char *retVal;
 194     retVal = ::getenv(envVarName);
 195     return retVal;
 196 }
 197
 198 int os::setenv(const char *envVarName, const char *value)
 199 {
 200 #ifdef SOLARIS
 201     char str[IDENTIFIER_LENGTH*3];
 202     sprintf(str, "%s=%s", envVarName, value);
 203     return putenv(str);
 204 #else
 205     return ::setenv(envVarName, value,1);
 206 #endif
 207 }
 208
 209 int os::kill(pid_t pid, int sig)
 210 {
 211     return ::kill(pid, sig);
 212 }
 213 bool os::atobool(char *value)
 214 {
 215     if (strlen(value) ==3 && strncasecmp(value,"YES",3)==0) return true;
 216     else if (strlen(value) ==2 && strncasecmp(value,"NO", 2)==0) return false;
 217     else if (strlen(value) ==4 && strncasecmp(value,"true",4)==0) return true;
 218     else if (strlen(value) ==5 && strncasecmp(value,"false",5)==0) return false;
 219     return false;
 220 }
 221 pid_t os::createProcess(const char* cmdName, const char* execName)
 222 {
 223     pid_t pid;
 224     pid = ::fork();
 225     if (pid == (pid_t) -1 )
 226     {
 227         printf("Process creation failed\n");
 228         return -1;
 229     }
 230     if (pid >0)
 231     {
 232         //return for parent
 233         return pid;
 234     }
 235     pid=::execl(cmdName,execName, NULL);
 236     if (pid < 0)
 237         printf("Exec failed\n");
 238     return pid;
 239 }
 240 pid_t os::fork()
 241 {
 242     return ::fork();
 243 }
 244 size_t os::send(int fd, const void *buf, size_t len, int flags)
 245 {
 246     size_t totalLen = len;
 247     size_t nbytes = ::send(fd, buf, len, flags);
 248     while (nbytes != -1 && nbytes != len) {
 249         len = len - nbytes;
 250         nbytes = ::send(fd, ((char *)buf)+nbytes, len, flags);
 251     }
 252     if (nbytes == -1) return -1;
 253     else return totalLen;
 254 }
 255 size_t os::recv(int fd, void *buf, size_t len, int flags)
 256 {
 257     size_t totalLen = len;
 258     size_t nbytes = ::recv(fd, buf, len, flags);
 259     if (!nbytes) return 0;
 260     while (nbytes != -1 && nbytes != len) {
 261         len = len - nbytes;
 262         nbytes = ::recv(fd, ((char *)buf)+nbytes, len, flags);
 263     }
 264     if (nbytes == -1) return -1;
 265     else return totalLen;
 266 }
 267 int os::gethostname(char *hostname, size_t len)
 268 {
 269     return ::gethostname(hostname, len);
 270 }
 271 int os::strmatch(char *pattern, char *str)
 272 {
 273     return ::fnmatch(pattern, str, 0);
 274 }
 275
 276 int os::msgget(key_t key, int oflag)
 277 {
 278     return ::msgget(key, oflag | IPC_CREAT);
 279 }
 280
 281 int os::msgsnd(int msqid, const void *ptr, size_t len, int flag)
 282 {
 283     return ::msgsnd(msqid, ptr, len, flag);
 284 }
 285
 286 ssize_t os::msgrcv(int msqid, void *ptr, size_t len, long type, int flag)
 287 {
 288     return ::msgrcv(msqid, ptr, len, type, flag);
 289 };
 290
 291 int os::msgctl(int msqid, int cmd, struct msqid_ds *buff)
 292 {
 293     return ::msgctl(msqid, cmd, buff);
 294 }
 295 bool os::fileExists(char *fileName)
 296 {
 297     int ret = access(fileName, R_OK);
 298     if (0 == ret) return true; else return false;
 299 }
 300 int os::isValidIP(char ipstr[] )
 301 {
 302 #if defined(LINUX)
 303     struct ifaddrs * ifAddrStruct=NULL;
 304     void * tmpAddrPtr=NULL;
 305     char  addressBuffer[100];
 306     int i=0;
 307     getifaddrs(&ifAddrStruct);
 308
 309     while (ifAddrStruct!=NULL)
 310     {
 311             if (ifAddrStruct->ifa_addr->sa_family==AF_INET && strcmp(ifAddrStruct->ifa_name, "lo0")!=0)
 312             {
 313                 tmpAddrPtr=&((struct sockaddr_in *)ifAddrStruct->ifa_addr)->sin_addr;
 314                 inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, 100);
 315                 if(strcmp(ipstr,addressBuffer) == 0)
 316                 {
 317           //         printf("\nThe ip is matched %s and %s",ipstr,addressBuffer);
 318                     return 1;
 319                 }
 320              //   printf("IP Address %s\n", inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, 100));
 321             }
 322             ifAddrStruct=ifAddrStruct->ifa_next;
 323     }
 324 #endif
 325     return 0;
 326 }
 327 char* os::strcasestr(char *str1, const char *str2)
 328 {
 329 #if defined(LINUX)
 330     return ::strcasestr(str1, str2);
 331 #else
 332     return ::strstr(str1, str2);
 333     /*
 334     int size=strlen(str1);
 335     char *tmpStr=new char[size];
 336     char *tmpStrPtr=NULL;
 337     strcpy(tmpStr, str1);
 338     tmpStrPtr=tmpStr;
 339     while(*tmpStrPtr != '\0')
 340     {
 341         *tmpStrPtr=::toupper(*tmpStrPtr);
 342         tmpStrPtr++;
 343     }
 344     char *subStrPtr = ::strstr(tmpStr, str2);
 345     delete []tmpStr;
 346     return subStrPtr;
 347     */
 348 #endif
 349 }
 350 int os::getNoOfProcessors()
 351 {
 352     return ::sysconf(_SC_NPROCESSORS_ONLN);
 353 }
 354 mode_t os::umask(mode_t mask)
 355 {
 356     return::umask(mask);
 357 }
 358 int os::fdatasync(int fd)
 359 {
 360 #ifdef FreeBSD
 361     return ::fsync(fd);
 362 #else
 363     return ::fdatasync(fd);
 364 #endif
 365 }
 366