/* To share the semaphores with other processes, we need a NULL ACL
* Code from MS KB Q106387
*/
PSECURITY_ATTRIBUTES GetNullACL()
{
PSECURITY_DESCRIPTOR pSD;
PSECURITY_ATTRIBUTES sa;
sa = (PSECURITY_ATTRIBUTES) LocalAlloc(LPTR, sizeof(SECURITY_ATTRIBUTES));
sa->nLength = sizeof(sizeof(SECURITY_ATTRIBUTES));
pSD = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR, SECURITY_DESCRIPTOR_MIN_LENGTH);
sa->lpSecurityDescriptor = pSD;
if (pSD == NULL || sa == NULL) {
return NULL;
}
apr_set_os_error(0);
if (!InitializeSecurityDescriptor(pSD, SECURITY_DESCRIPTOR_REVISION)
|| apr_get_os_error()) {
LocalFree( pSD );
LocalFree( sa );
return NULL;
}
if (!SetSecurityDescriptorDacl(pSD, TRUE, (PACL) NULL, FALSE)
|| apr_get_os_error()) {
LocalFree( pSD );
LocalFree( sa );
return NULL;
}
sa->bInheritHandle = FALSE;
return sa;
}
apr_status_t
svn_subr__win32_xlate_to_stringbuf(win32_xlate_t *handle,
const char *src_data,
apr_size_t src_length,
svn_stringbuf_t **dest,
apr_pool_t *pool)
{
WCHAR * wide_str;
int retval, wide_size;
if (src_length == 0)
{
*dest = svn_stringbuf_create_empty(pool);
return APR_SUCCESS;
}
retval = MultiByteToWideChar(handle->from_page_id, 0, src_data, src_length,
NULL, 0);
if (retval == 0)
return apr_get_os_error();
wide_size = retval;
/* Allocate temporary buffer for small strings on stack instead of heap. */
if (wide_size <= MAX_PATH)
{
wide_str = alloca(wide_size * sizeof(WCHAR));
}
else
{
wide_str = apr_palloc(pool, wide_size * sizeof(WCHAR));
}
retval = MultiByteToWideChar(handle->from_page_id, 0, src_data, src_length,
wide_str, wide_size);
if (retval == 0)
return apr_get_os_error();
retval = WideCharToMultiByte(handle->to_page_id, 0, wide_str, wide_size,
NULL, 0, NULL, NULL);
if (retval == 0)
return apr_get_os_error();
/* Ensure that buffer is enough to hold result string and termination
character. */
*dest = svn_stringbuf_create_ensure(retval + 1, pool);
(*dest)->len = retval;
retval = WideCharToMultiByte(handle->to_page_id, 0, wide_str, wide_size,
(*dest)->data, (*dest)->len, NULL, NULL);
if (retval == 0)
return apr_get_os_error();
(*dest)->len = retval;
return APR_SUCCESS;
}
void lt_server_logger_print_apr( int priority, const char * aprcall,
const char * format, ... )
{
va_list ap;
char error[1025];
if( priority > _logger_priority ) return;
va_start( ap, format );
vprintf( format, ap );
va_end( ap );
apr_strerror( apr_get_os_error(), error, 1024 );
printf( "APR ERROR while calling %s: (%li) %s\n",
aprcall, (long)apr_get_os_error(), error );
fflush( stdout );
}
APR_DECLARE(apr_status_t) port_vmem_reserve(port_vmem_t **block, void **address,
size_t amount, unsigned int mode,
size_t pageSize, apr_pool_t *pool){
void *start = 0;
DWORD action = MEM_RESERVE;
DWORD protection = PAGE_NOACCESS;
int large = 0;
size_t* ps = port_vmem_page_sizes();
if ((pageSize == PORT_VMEM_PAGESIZE_LARGE && ps[1] != 0)
|| pageSize > ps[0]) {
/* Using large pages on Win64 seems to require MEM_COMMIT and PAGE_READWRITE.*/
action = MEM_COMMIT | MEM_LARGE_PAGES;
protection = PAGE_READWRITE;
large = 1;
}
start = VirtualAlloc(*address, amount, action, protection);
if (!start) {
return apr_get_os_error();
}
*block = apr_palloc(pool, sizeof(port_vmem_t));
(*block)->pool = pool;
(*block)->start = start;
(*block)->size = amount;
(*block)->protection = convertProtectionMask(mode);
(*block)->large = large;
*address = start;
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) apr_dso_sym(apr_dso_handle_sym_t *ressym,
struct apr_dso_handle_t *handle,
const char *symname)
{
#ifdef _WIN32_WCE
apr_size_t symlen = strlen(symname) + 1;
apr_size_t wsymlen = 256;
apr_wchar_t wsymname[256];
apr_status_t rv;
rv = apr_conv_utf8_to_ucs2(wsymname, &wsymlen, symname, &symlen);
if (rv != APR_SUCCESS) {
return rv;
}
else if (symlen) {
return APR_ENAMETOOLONG;
}
*ressym = (apr_dso_handle_sym_t)GetProcAddressW(handle->handle, wsymname);
#else
*ressym = (apr_dso_handle_sym_t)GetProcAddress(handle->handle, symname);
#endif
if (!*ressym) {
return apr_get_os_error();
}
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex)
{
if (ReleaseMutex(mutex->handle) == 0) {
return apr_get_os_error();
}
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) port_vmem_free(void *addr, size_t UNREF size)
{
if (!VirtualFree(addr, 0, MEM_RELEASE)) {
return apr_get_os_error();
}
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) apr_thread_mutex_unlock(apr_thread_mutex_t *mutex)
{
if (mutex->type == thread_mutex_critical_section) {
LeaveCriticalSection(&mutex->section);
}
else if (mutex->type == thread_mutex_unnested_event) {
if (!SetEvent(mutex->handle)) {
return apr_get_os_error();
}
}
else if (mutex->type == thread_mutex_nested_mutex) {
if (!ReleaseMutex(mutex->handle)) {
return apr_get_os_error();
}
}
return APR_SUCCESS;
}
apr_status_t filepath_drive_get(char **rootpath, char drive,
apr_int32_t flags, apr_pool_t *p)
{
char path[APR_PATH_MAX];
#if APR_HAS_UNICODE_FS
IF_WIN_OS_IS_UNICODE
{
apr_wchar_t *ignored;
apr_wchar_t wdrive[8];
apr_wchar_t wpath[APR_PATH_MAX];
apr_status_t rv;
/* ???: This needs review, apparently "\\?\d:." returns "\\?\d:"
* as if that is useful for anything.
*/
wcscpy(wdrive, L"D:.");
wdrive[0] = (apr_wchar_t)(unsigned char)drive;
#ifndef OS_WINCE
if (!GetFullPathNameW(wdrive, sizeof(wpath) / sizeof(apr_wchar_t), wpath, &ignored))
return apr_get_os_error();
#endif
if ((rv = unicode_to_utf8_path(path, sizeof(path), wpath)))
return rv;
}
#endif
#if APR_HAS_ANSI_FS
ELSE_WIN_OS_IS_ANSI
{
char *ignored;
char drivestr[4];
drivestr[0] = drive;
drivestr[1] = ':';
drivestr[2] = '.';;
drivestr[3] = '\0';
if (!GetFullPathName(drivestr, sizeof(path), path, &ignored))
return apr_get_os_error();
}
#endif
if (!(flags & APR_FILEPATH_NATIVE)) {
for (*rootpath = path; **rootpath; ++*rootpath) {
if (**rootpath == '\\')
**rootpath = '/';
}
}
*rootpath = apr_pstrdup(p, path);
return APR_SUCCESS;
}
static apr_status_t dir_cleanup(void *thedir)
{
apr_dir_t *dir = thedir;
if (dir->dirhand != INVALID_HANDLE_VALUE && !FindClose(dir->dirhand)) {
return apr_get_os_error();
}
dir->dirhand = INVALID_HANDLE_VALUE;
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) port_vmem_release(/*void *address, size_t amount,*/
port_vmem_t *block){
if (!VirtualFree(block->start, 0, MEM_RELEASE)) {
return apr_get_os_error();
}
return APR_SUCCESS;
}
static apr_status_t shm_cleanup(void* shm)
{
apr_status_t rv = APR_SUCCESS;
apr_shm_t *m = shm;
if (!UnmapViewOfFile(m->memblk)) {
rv = apr_get_os_error();
}
if (!CloseHandle(m->hMap)) {
rv = rv != APR_SUCCESS ? rv : apr_get_os_error();
}
if (m->filename) {
/* Remove file if file backed */
apr_status_t rc = apr_file_remove(m->filename, m->pool);
rv = rv != APR_SUCCESS ? rv : rc;
}
return rv;
}
svn_error_t *
svn_cl__error_checked_fputs(const char *string, FILE* stream)
{
/* On POSIX systems, errno will be set on an error in fputs, but this might
not be the case on other platforms. We reset errno and only
use it if it was set by the below fputs call. Else, we just return
a generic error. */
errno = 0;
if (fputs(string, stream) == EOF)
{
if (apr_get_os_error()) /* is errno on POSIX */
return svn_error_wrap_apr(apr_get_os_error(), _("Write error"));
else
return svn_error_create(SVN_ERR_IO_WRITE_ERROR, NULL, NULL);
}
return SVN_NO_ERROR;
}
static apr_status_t dso_cleanup(void *thedso)
{
apr_dso_handle_t *dso = thedso;
if (dso->handle != NULL && !FreeLibrary(dso->handle)) {
return apr_get_os_error();
}
dso->handle = NULL;
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
{
DWORD rv;
rv = WaitForSingleObject(mutex->handle, INFINITE);
if (rv == WAIT_OBJECT_0 || rv == WAIT_ABANDONED) {
return APR_SUCCESS;
}
return apr_get_os_error();
}
static apr_status_t proc_mutex_cleanup(void *mutex_)
{
apr_proc_mutex_t *mutex = mutex_;
if (mutex->handle) {
if (CloseHandle(mutex->handle) == 0) {
return apr_get_os_error();
}
}
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) port_vmem_decommit(void *address, size_t amount,
port_vmem_t *block){
if (block->large) {
return APR_SUCCESS;
}
if (!VirtualFree(address, amount, MEM_DECOMMIT)) {
return apr_get_os_error();
}
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) port_vmem_commit(void **address, size_t amount,
port_vmem_t *block){
size_t page = block->page;
void *aligned = (void *)(((long)*address + page-1) & ~(page-1));
errno = 0;
if(mprotect(aligned, amount, block->protection)) {
return apr_get_os_error();
}
*address = aligned;
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) apr_file_trunc(apr_file_t *thefile, apr_off_t offset)
{
apr_status_t rv;
DWORD offlo = (DWORD)offset;
LONG offhi = (LONG)(offset >> 32);
DWORD rc;
rc = SetFilePointer(thefile->filehand, offlo, &offhi, FILE_BEGIN);
if (rc == 0xFFFFFFFF)
if ((rv = apr_get_os_error()) != APR_SUCCESS)
return rv;
if (!SetEndOfFile(thefile->filehand))
return apr_get_os_error();
if (thefile->buffered) {
return setptr(thefile, offset);
}
return APR_SUCCESS;
}
static apr_status_t mmap_cleanup(void *themmap)
{
apr_mmap_t *mm = themmap;
apr_mmap_t *next = APR_RING_NEXT(mm,link);
apr_status_t rv = 0;
/* we no longer refer to the mmaped region */
APR_RING_REMOVE(mm,link);
APR_RING_NEXT(mm,link) = NULL;
APR_RING_PREV(mm,link) = NULL;
if (next != mm) {
/* more references exist, so we're done */
return APR_SUCCESS;
}
if (mm->mv) {
if (!UnmapViewOfFile(mm->mv))
{
apr_status_t rv = apr_get_os_error();
CloseHandle(mm->mhandle);
mm->mv = NULL;
mm->mhandle = NULL;
return rv;
}
mm->mv = NULL;
}
if (mm->mhandle)
{
if (!CloseHandle(mm->mhandle))
{
apr_status_t rv = apr_get_os_error();
CloseHandle(mm->mhandle);
mm->mhandle = NULL;
return rv;
}
mm->mhandle = NULL;
}
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
const char *fname,
apr_pool_t *pool)
{
HANDLE hMutex;
void *mutexkey;
if (!fname) {
/* Reinitializing unnamed mutexes is a noop in the Unix code. */
return APR_SUCCESS;
}
/* res_name_from_filename turns file into a pseudo-name
* without slashes or backslashes, and prepends the \global
* prefix on Win2K and later
*/
mutexkey = res_name_from_filename(fname, 1, pool);
#if defined(_WIN32_WCE)
hMutex = CreateMutex(NULL, FALSE, mutexkey);
if (hMutex && ERROR_ALREADY_EXISTS != GetLastError()) {
CloseHandle(hMutex);
hMutex = NULL;
SetLastError(ERROR_FILE_NOT_FOUND);
}
#else
#if APR_HAS_UNICODE_FS
IF_WIN_OS_IS_UNICODE
{
hMutex = OpenMutexW(MUTEX_ALL_ACCESS, FALSE, mutexkey);
}
#endif
#if APR_HAS_ANSI_FS
ELSE_WIN_OS_IS_ANSI
{
hMutex = OpenMutexA(MUTEX_ALL_ACCESS, FALSE, mutexkey);
}
#endif
#endif
if (!hMutex) {
return apr_get_os_error();
}
*mutex = (apr_proc_mutex_t *)apr_palloc(pool, sizeof(apr_proc_mutex_t));
(*mutex)->pool = pool;
(*mutex)->handle = hMutex;
(*mutex)->fname = fname;
apr_pool_cleanup_register((*mutex)->pool, *mutex,
proc_mutex_cleanup, apr_pool_cleanup_null);
return APR_SUCCESS;
}
/**
* Returns OS name and version.
*/
APR_DECLARE(apr_status_t) port_OS_name_version(char** os_name, char** os_ver,
apr_pool_t* pool){
struct utsname sys_info;
int ret = uname(&sys_info);
if (-1 == ret) {
return apr_get_os_error();
}
*os_name = apr_pstrdup(pool, sys_info.sysname);
*os_ver = apr_pstrdup(pool, sys_info.release);
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) port_vmem_allocate(void **addr, size_t size, unsigned int mode)
{
LPVOID start = NULL;
DWORD protection = convertProtectionMask(mode);
start = VirtualAlloc(*addr, size, MEM_COMMIT, protection);
if (!start) {
return apr_get_os_error();
}
*addr = start;
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) apr_thread_mutex_lock(apr_thread_mutex_t *mutex)
{
if (mutex->type == thread_mutex_critical_section) {
EnterCriticalSection(&mutex->section);
}
else {
DWORD rv = WaitForSingleObject(mutex->handle, INFINITE);
if ((rv != WAIT_OBJECT_0) && (rv != WAIT_ABANDONED)) {
return (rv == WAIT_TIMEOUT) ? APR_EBUSY : apr_get_os_error();
}
}
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) port_vmem_commit(void **address, size_t amount,
port_vmem_t *block){
void *start = 0;
if (block->large) {
return APR_SUCCESS;
}
start = VirtualAlloc(*address, amount, MEM_COMMIT, block->protection);
if (!start) {
return apr_get_os_error();
}
*address = start;
return APR_SUCCESS;
}
/* Windows only really support killing process, but that will do for now.
*
* ### Actually, closing the input handle to the proc should also do fine
* for most console apps. This definately needs improvement...
*/
APR_DECLARE(apr_status_t) apr_proc_kill(apr_proc_t *proc, int signal)
{
if (proc->hproc != NULL) {
if (TerminateProcess(proc->hproc, signal) == 0) {
return apr_get_os_error();
}
/* On unix, SIGKILL leaves a apr_proc_wait()able pid lying around,
* so we will leave hproc alone until the app calls apr_proc_wait().
*/
return APR_SUCCESS;
}
return APR_EPROC_UNKNOWN;
}
APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex)
{
DWORD rv;
rv = WaitForSingleObject(mutex->handle, 0);
if (rv == WAIT_OBJECT_0 || rv == WAIT_ABANDONED) {
return APR_SUCCESS;
}
else if (rv == WAIT_TIMEOUT) {
return APR_EBUSY;
}
return apr_get_os_error();
}
AP_DECLARE(apr_status_t) ap_os_proc_filepath(char **binpath, apr_pool_t *p)
{
apr_wchar_t wbinpath[APR_PATH_MAX];
#if APR_HAS_UNICODE_FS
IF_WIN_OS_IS_UNICODE
{
apr_size_t binlen;
apr_size_t wbinlen;
apr_status_t rv;
if (!GetModuleFileNameW(NULL, wbinpath, sizeof(wbinpath)
/ sizeof(apr_wchar_t))) {
return apr_get_os_error();
}
wbinlen = wcslen(wbinpath) + 1;
binlen = (wbinlen - 1) * 3 + 1;
*binpath = apr_palloc(p, binlen);
rv = apr_conv_ucs2_to_utf8(wbinpath, &wbinlen, *binpath, &binlen);
if (rv != APR_SUCCESS)
return rv;
else if (wbinlen)
return APR_ENAMETOOLONG;
}
#endif /* APR_HAS_UNICODE_FS */
#if APR_HAS_ANSI_FS
ELSE_WIN_OS_IS_ANSI
{
/* share the same scratch buffer */
char *pathbuf = (char*) wbinpath;
if (!GetModuleFileName(NULL, pathbuf, sizeof(wbinpath))) {
return apr_get_os_error();
}
*binpath = apr_pstrdup(p, pathbuf);
}
#endif
return APR_SUCCESS;
}
static apr_status_t thread_mutex_cleanup(void *data)
{
apr_thread_mutex_t *lock = data;
if (lock->type == thread_mutex_critical_section) {
lock->type = -1;
DeleteCriticalSection(&lock->section);
}
else {
if (!CloseHandle(lock->handle)) {
return apr_get_os_error();
}
}
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) apr_uid_current(apr_uid_t *uid,
apr_gid_t *gid,
apr_pool_t *p)
{
#ifdef _WIN32_WCE
return APR_ENOTIMPL;
#else
HANDLE threadtok;
DWORD needed;
TOKEN_USER *usr;
TOKEN_PRIMARY_GROUP *grp;
if(!OpenProcessToken(GetCurrentProcess(), STANDARD_RIGHTS_READ | READ_CONTROL | TOKEN_QUERY, &threadtok)) {
return apr_get_os_error();
}
*uid = NULL;
if (!GetTokenInformation(threadtok, TokenUser, NULL, 0, &needed)
&& (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
&& (usr = apr_palloc(p, needed))
&& GetTokenInformation(threadtok, TokenUser, usr, needed, &needed))
*uid = usr->User.Sid;
else
return apr_get_os_error();
if (!GetTokenInformation(threadtok, TokenPrimaryGroup, NULL, 0, &needed)
&& (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
&& (grp = apr_palloc(p, needed))
&& GetTokenInformation(threadtok, TokenPrimaryGroup, grp, needed, &needed))
*gid = grp->PrimaryGroup;
else
return apr_get_os_error();
return APR_SUCCESS;
#endif
}