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