1 /***************************************************************************
2 * Copyright (C) 2007 by www.databasecache.com *
3 * Contact: praba_tuty@databasecache.com *
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. *
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. *
15 ***************************************************************************/
19 void* os::mmap(void* addr
, size_t len
, int prot
, int flags
, file_desc fildes
, off_t off
)
22 HANDLE hFile
= ::CreateFileMapping(fildes
,
23 NULL
, prot
, 0, off
, NULL
);
26 printf("unable to do mmap\n");
29 return ::MapViewOfFileEx(hFile
, FILE_MAP_WRITE
, 0, 0, off
, addr
);
31 return ((void*)::mmap((char*)addr
,len
,prot
,flags
,fildes
,off
));
33 return ((void*)::mmap(addr
,len
,prot
,flags
,fildes
,off
));
37 int os::munmap(caddr_t addr
, size_t len
)
40 return ::UnmapViewOfFile(addr
);
42 return ::munmap(addr
, len
);
46 int os::atexit(void (*exitHndlr
)(void))
48 return ::atexit(exitHndlr
);
51 shared_memory_id
os::shm_create(shared_memory_key key
, size_t size
, int flag
)
54 char fName
[MAX_FILE_PATH_LEN
];
55 sprintf(fName
, "SHM_ID_%d", key
);
56 HANDLE hFile
= ::CreateFileMapping(INVALID_HANDLE_VALUE
,
57 NULL
, PAGE_READWRITE
, 0, size
, NULL
);
60 printf("unable to do shm_create\n");
65 return ::shmget(key
, size
, IPC_CREAT
| IPC_EXCL
| flag
);
69 shared_memory_id
os::shm_open(shared_memory_key key
, size_t size
, int flag
)
72 return shm_create(key
, size
, flag
);
74 return ::shmget(key
, size
, flag
);
77 int os::shmctl(int shmid
, int cmd
)
80 printf("WINDOWS shm_open not implemented\n");
83 return ::shmctl(shmid
, cmd
, NULL
);
86 int os::shm_remove(int shmid
)
89 printf("WINDOWS shmremove not implemented\n");
92 return ::shmctl(shmid
, IPC_RMID
, NULL
);
96 void* os::shm_attach(shared_memory_id id
, const void *ptr
, int flag
)
99 char fName
[MAX_FILE_PATH_LEN
];
100 sprintf(fName
, "SHM_ID_%d", id
);
101 HANDLE hFile
= ::OpenFileMapping(FILE_MAP_ALL_ACCESS
,false, fName
);
104 printf("unable to do mmap\n");
107 return ::MapViewOfFileEx(hFile
, FILE_MAP_WRITE
, 0, 0, 0, (void*)ptr
);
109 return ::shmat(id
, ptr
, flag
);
113 int os::shm_detach (void* addr
)
116 return ::UnmapViewOfFile(addr
);
118 return ::shmdt((char*)addr
);
122 int os::gettimeofday(struct timeval
*tp
)
127 unsigned __int64 tmpres
= 0;
128 GetSystemTimeAsFileTime(&ft
);
130 // The GetSystemTimeAsFileTime returns the number of 100 nanosecond
131 // intervals since Jan 1, 1601 in a structure. Copy the high bits to
132 // the 64 bit tmpres, shift it left by 32 then or in the low 32 bits.
133 tmpres
|= ft
.dwHighDateTime
;
135 tmpres
|= ft
.dwLowDateTime
;
137 // Convert to microseconds by dividing by 10
140 // The Unix epoch starts on Jan 1 1970. Need to subtract the difference
141 // in seconds from Jan 1 1601.
142 tmpres
-= DELTA_EPOCH_IN_MICROSECS
;
144 // Finally change microseconds to seconds and place in the seconds value.
145 // The modulus picks up the microseconds.
146 tp
->tv_sec
= (long)(tmpres
/ 1000000UL);
147 tp
->tv_usec
= (long)(tmpres
% 1000000UL);
149 retval
=::gettimeofday(tp
, NULL
);
154 struct tm
* os::localtime(long *secs
)
157 return (struct tm
*) ::localtime(secs
);
159 return ::localtime((const time_t*)secs
);
161 return ::localtime(secs
);
164 int os::open(const char *name
, FileOpenMode flags
, size_t size
)
167 mode_t oldMode
= umask(0000);
168 mode_t mode
= (mode_t
)0644 ;
169 retval
=::open(name
, flags
, mode
);
173 os::lseek(retval
, size
-1, SEEK_SET
);
174 char *buf
= (char*)" ";
175 os::write(retval
, buf
, 1);
178 int os::close(int fd
)
183 file_desc
os::openFile(const char *name
, FileOpenMode flags
, size_t size
)
187 HANDLE hFile
= CreateFile(name
, GENERIC_READ
| GENERIC_WRITE
,
188 FILE_SHARE_WRITE
, NULL
, OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
190 if (hFile
== INVALID_HANDLE_VALUE
)
192 printf("Unable to open file %s \n", name
);
193 return (file_desc
) -1;
196 return (file_desc
) hFile
;
197 mode_t mode
= (mode_t
)0644 ;
198 int retval
=::open(name
, flags
, mode
);
199 os::lseek(retval
, size
-1, SEEK_SET
);
200 char *buf
= (char*)" ";
201 os::write(retval
, buf
, 1);
203 return (file_desc
) retval
;
206 //mode_t mode = S_IRWXU | S_IRGRP | S_IWGRP ;
207 mode_t oldMode
= umask(0000);
208 mode_t mode
= (mode_t
)0644 ;
209 retval
=::open(name
, flags
, mode
);
212 return (file_desc
) retval
;
213 os::lseek(retval
, size
-1, SEEK_SET
);
214 char *buf
= (char*)" ";
215 os::write(retval
, buf
, 1);
216 return (file_desc
) retval
;
219 int os::openFileForAppend(const char *name
, int flag
)
221 mode_t mode
= (mode_t
)0644 ;
222 int flags
= flag
| O_WRONLY
|O_APPEND
;
223 return ::open(name
, flags
, mode
);
226 int os::closeFile(file_desc fd
)
229 return ::CloseHandle(fd
);
234 int os::lockFile(int fd
)
238 printf("SOLARIS lockFile not implemented\n");
241 printf("WINDOWS lockFile not implemented\n");
244 return flock(fd
, LOCK_EX
);
247 int os::unlockFile(int fd
)
250 printf("Solaris unlockFile not implemented\n");
254 printf("WINDOWS unlockFile not implemented\n");
257 return ::flock(fd
, LOCK_UN
);
261 off_t
os::lseek(int fildes
, off_t offset
, int whence
)
263 return ::lseek(fildes
, offset
, whence
);
266 size_t os::write(int fildes
, char *buf
, size_t size
)
268 return ::write(fildes
, buf
, size
);
271 int os::msync(caddr_t addr
, size_t len
, int flags
)
274 printf("WINDOWS msync not implemented\n");
277 return ::msync(addr
, len
, flags
);
280 int os::fsync(int fildes
)
283 printf("WINDOWS fsync not implemented\n");
286 return ::fsync(fildes
);
290 char* os::encrypt(const char *key
, const char *salt
)
293 printf("WINDOWS encrypt not implemented\n");
296 return ::crypt(key
, salt
);
300 void* os::memset(void *src
, int c
, size_t size
)
302 return::memset(src
, c
, size
);
305 void* os::memcpy(void *src
, const void *dest
, size_t size
)
307 return ::memcpy(src
, dest
, size
);
310 int os::memcmp(const void *s1
, const void *s2
, size_t size
)
312 return ::memcmp(s1
, s2
, size
);
314 sighandler_t
os::signal(int signum
, sighandler_t handler
)
317 printf("WINDOWS signal not implemented\n");
320 return ::signal(signum
, handler
);
324 int os::select(int nfds
, fd_set
*readfds
, fd_set
*writefds
,
325 fd_set
*exceptfds
, struct timeval
* timeout
)
327 return ::select(nfds
, readfds
, writefds
, exceptfds
, timeout
);
329 int os::sleep(int secs
)
335 return ::sleep(secs
);
338 int os::usleep(int msecs
)
340 struct timeval timeout
;
342 timeout
.tv_usec
= msecs
;
343 os::select(0,0,0,0, &timeout
);
346 int os::getFileSize(const char *fileName
)
349 stat(fileName
, &buf
);
353 char* os::getenv(const char *envVarName
)
356 retVal
= ::getenv(envVarName
);
360 int os::setenv(const char *envVarName
, const char *value
)
363 char str
[IDENTIFIER_LENGTH
*3];
364 sprintf(str
, "%s=%s", envVarName
, value
);
367 printf("WINDOWS setenv not implemented \n");
370 return ::setenv(envVarName
, value
,1);
374 int os::kill(pid_t pid
, int sig
)
377 printf("WINDOWS kill not implemented\n");
380 return ::kill(pid
, sig
);
383 bool os::atobool(char *value
)
385 if (strlen(value
) ==3 && strncasecmp(value
,"YES",3)==0) return true;
386 else if (strlen(value
) ==2 && strncasecmp(value
,"NO", 2)==0) return false;
387 else if (strlen(value
) ==4 && strncasecmp(value
,"true",4)==0) return true;
388 else if (strlen(value
) ==5 && strncasecmp(value
,"false",5)==0) return false;
391 pid_t
os::createProcess(const char* cmdName
, const char* execName
)
394 printf("WINDOWS: createProcess implemented partially\n");
396 PROCESS_INFORMATION pinfo
;
397 ZeroMemory( &sinfo
, sizeof(sinfo
) );
398 sinfo
.cb
= sizeof(sinfo
);
399 ZeroMemory( &pinfo
, sizeof(pinfo
) );
401 if (!::CreateProcess(cmdName
, NULL
, NULL
, NULL
, FALSE
, 0, NULL
, NULL
,
406 return (pid_t
)pinfo
.dwProcessId
;
410 if (pid
== (pid_t
) -1 )
412 printf("Process creation failed\n");
420 pid
=::execl(cmdName
,execName
, NULL
);
422 printf("Exec failed\n");
429 printf("WINDOWS: fork not implemented\n");
435 size_t os::send(int fd
, const void *buf
, size_t len
, int flags
)
437 size_t totalLen
= len
;
438 size_t nbytes
= ::send(fd
, (char*)buf
, len
, flags
);
439 while (nbytes
!= -1 && nbytes
!= len
) {
441 nbytes
= ::send(fd
, ((char *)buf
)+nbytes
, len
, flags
);
443 if (nbytes
== -1) return -1;
444 else return totalLen
;
446 size_t os::recv(int fd
, void *buf
, size_t len
, int flags
)
448 size_t totalLen
= len
;
449 size_t nbytes
= ::recv(fd
, (char*)buf
, len
, flags
);
450 if (!nbytes
) return 0;
451 while (nbytes
!= -1 && nbytes
!= len
) {
453 nbytes
= ::recv(fd
, ((char *)buf
)+nbytes
, len
, flags
);
455 if (nbytes
== -1) return -1;
456 else return totalLen
;
458 int os::gethostname(char *hostname
, size_t len
)
460 return ::gethostname(hostname
, len
);
462 int os::strmatch(char *pattern
, char *str
)
465 printf("WINDOWS: strmatch not implemented\n");
468 return ::fnmatch(pattern
, str
, 0);
472 int os::msgget(key_t key
, int oflag
)
475 printf("WINDOWS: msgget not implemented\n");
478 return ::msgget(key
, oflag
| IPC_CREAT
);
482 int os::msgsnd(int msqid
, const void *ptr
, size_t len
, int flag
)
485 printf("WINDOWS: msgsnd not implemented\n");
488 return ::msgsnd(msqid
, ptr
, len
, flag
);
492 int os::msgrcv(int msqid
, void *ptr
, size_t len
, long type
, int flag
)
495 printf("WINDOWS: msgrcv not implemented\n");
498 return ::msgrcv(msqid
, ptr
, len
, type
, flag
);
502 int os::msgctl(int msqid
, int cmd
, struct msqid_ds
*buff
)
505 printf("WINDOWS: msgctl not implemented\n");
508 return ::msgctl(msqid
, cmd
, buff
);
511 bool os::fileExists(char *fileName
)
514 int ret
= _access(fileName
, 04);
515 if (0 == ret
) return true; else return false;
517 int ret
= access(fileName
, R_OK
);
518 if (0 == ret
) return true; else return false;
521 int os::isValidIP(char ipstr
[] )
524 struct ifaddrs
* ifAddrStruct
=NULL
;
525 void * tmpAddrPtr
=NULL
;
526 char addressBuffer
[100];
528 getifaddrs(&ifAddrStruct
);
530 while (ifAddrStruct
!=NULL
)
532 if (ifAddrStruct
->ifa_addr
->sa_family
==AF_INET
&& strcmp(ifAddrStruct
->ifa_name
, "lo0")!=0)
534 tmpAddrPtr
=&((struct sockaddr_in
*)ifAddrStruct
->ifa_addr
)->sin_addr
;
535 inet_ntop(AF_INET
, tmpAddrPtr
, addressBuffer
, 100);
536 if(strcmp(ipstr
,addressBuffer
) == 0)
538 // printf("\nThe ip is matched %s and %s",ipstr,addressBuffer);
541 // printf("IP Address %s\n", inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, 100));
543 ifAddrStruct
=ifAddrStruct
->ifa_next
;
548 char* os::strcasestr(char *str1
, const char *str2
)
551 return ::strcasestr(str1
, str2
);
553 return ::strstr(str1
, str2
);
555 int size=strlen(str1);
556 char *tmpStr=new char[size];
557 char *tmpStrPtr=NULL;
558 strcpy(tmpStr, str1);
560 while(*tmpStrPtr != '\0')
562 *tmpStrPtr=::toupper(*tmpStrPtr);
565 char *subStrPtr = ::strstr(tmpStr, str2);
571 int os::getNoOfProcessors()
574 printf("WINDOWS: getNoOfProcessors not implemented\n");
577 return ::sysconf(_SC_NPROCESSORS_ONLN
);
580 mode_t
os::umask(mode_t mask
)
584 int os::fdatasync(file_desc fd
)
589 printf("WINDOWS: fdatasync not implemented\n");
592 return ::fdatasync(fd
);
598 return ::GetCurrentThreadId();
603 pthread_t
os::getthrid()
606 return ::GetCurrentThreadId();
608 return ::pthread_self();
612 int os::truncate(const char* filename
)
616 if (fh
= ::_open(filename
, _O_RDWR
) == 0)
618 result
= _chsize(fh
, 0);
623 return ::truncate(filename
, 0);
627 void* os::dlsym(LHANDLE hdl
, char *fname
)
630 return ::GetProcAddress(hdl
, fname
);
632 return ::dlsym(hdl
, fname
);