int serialPutLines (SerialDevice *serial, SerialLines high, SerialLines low) { DCB dcb; dcb.DCBlength = sizeof(dcb); if (GetCommState(serial->package.fileHandle, &dcb)) { if (low & SERIAL_LINE_RTS) { dcb.fRtsControl = RTS_CONTROL_DISABLE; } else if (high & SERIAL_LINE_RTS) { dcb.fRtsControl = RTS_CONTROL_ENABLE; } if (low & SERIAL_LINE_DTR) { dcb.fDtrControl = DTR_CONTROL_DISABLE; } else if (high & SERIAL_LINE_DTR) { dcb.fDtrControl = DTR_CONTROL_ENABLE; } if (SetCommState(serial->package.fileHandle, &dcb)) return 1; logWindowsSystemError("SetCommState"); } else { logWindowsSystemError("GetCommState"); } return 0; }
int removeService (const char *name) { int removed = 0; SC_HANDLE scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); if (scm) { SC_HANDLE service = OpenService(scm, name, DELETE); if (service) { if (DeleteService(service)) { logMessage(LOG_NOTICE, "service removed: %s", name); removed = 1; } else if (GetLastError() == ERROR_SERVICE_MARKED_FOR_DELETE) { logMessage(LOG_WARNING, "service already being removed: %s", name); removed = 1; } else { logWindowsSystemError("DeleteService"); } CloseServiceHandle(service); } else if (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST) { logMessage(LOG_WARNING, "service not installed: %s", name); removed = 1; } else { logWindowsSystemError("OpenService"); } CloseServiceHandle(scm); } else { logWindowsSystemError("OpenSCManager"); } return removed; }
ssize_t serialPutData ( SerialDevice *serial, const void *data, size_t size ) { COMMTIMEOUTS timeouts = {MAXDWORD, 0, 0, 0, 15000}; size_t left = size; DWORD bytesWritten; if (!(SetCommTimeouts(serial->package.fileHandle, &timeouts))) { logWindowsSystemError("SetCommTimeouts serialWriteData"); setSystemErrno(); return -1; } while (left && WriteFile(serial->package.fileHandle, data, left, &bytesWritten, NULL)) { if (!bytesWritten) break; left -= bytesWritten; data += bytesWritten; } if (!left) return size; logWindowsSystemError("WriteFile"); return -1; }
int serialPollInput (SerialDevice *serial, int timeout) { if (serial->package.pendingCharacter != -1) return 1; { COMMTIMEOUTS timeouts = {MAXDWORD, 0, timeout, 0, 0}; DWORD bytesRead; char c; if (!(SetCommTimeouts(serial->package.fileHandle, &timeouts))) { logWindowsSystemError("SetCommTimeouts serialAwaitInput"); setSystemErrno(); return 0; } if (!ReadFile(serial->package.fileHandle, &c, 1, &bytesRead, NULL)) { logWindowsSystemError("ReadFile"); setSystemErrno(); return 0; } if (bytesRead) { serial->package.pendingCharacter = (unsigned char)c; return 1; } } errno = EAGAIN; return 0; }
ssize_t serialGetData ( SerialDevice *serial, void *buffer, size_t size, int initialTimeout, int subsequentTimeout ) { size_t length = 0; COMMTIMEOUTS timeouts = {MAXDWORD, 0, initialTimeout, 0, 0}; DWORD bytesRead; if (serial->package.pendingCharacter != -1) { * (unsigned char *) buffer = serial->package.pendingCharacter; serial->package.pendingCharacter = -1; bytesRead = 1; } else { if (!(SetCommTimeouts(serial->package.fileHandle, &timeouts))) { logWindowsSystemError("SetCommTimeouts serialReadChunk1"); setSystemErrno(); return -1; } if (!ReadFile(serial->package.fileHandle, buffer, size, &bytesRead, NULL)) { logWindowsSystemError("ReadFile"); setSystemErrno(); return -1; } if (!bytesRead) return 0; } size -= bytesRead; length += bytesRead; timeouts.ReadTotalTimeoutConstant = subsequentTimeout; if (!(SetCommTimeouts(serial->package.fileHandle, &timeouts))) { logWindowsSystemError("SetCommTimeouts serialReadChunk2"); setSystemErrno(); return -1; } while (size && ReadFile(serial->package.fileHandle, buffer + length, size, &bytesRead, NULL)) { if (!bytesRead) return length; size -= bytesRead; length += bytesRead; } if (!size) return length; logWindowsSystemError("ReadFile"); setSystemErrno(); return -1; }
char * getProgramPath (void) { char *path = NULL; HMODULE handle; if ((handle = GetModuleHandle(NULL))) { size_t size = 0X80; char *buffer = NULL; while (1) { { char *newBuffer = realloc(buffer, size<<=1); if (!newBuffer) { logMallocError(); break; } buffer = newBuffer; } { DWORD length = GetModuleFileName(handle, buffer, size); if (!length) { logWindowsSystemError("GetModuleFileName"); break; } if (length < size) { buffer[length] = 0; if ((path = strdup(buffer))) { while (length > 0) if (path[--length] == '\\') path[length] = '/'; } else { logMallocError(); } break; } } } free(buffer); } else { logWindowsSystemError("GetModuleHandle"); } return path; }
void * loadSharedObject (const char *path) { HMODULE library; if (!(library = LoadLibrary(path))) logWindowsSystemError("loading library"); return library; }
static int monitorWindowsPipeConnect (NamedPipeObject *obj) { if (ResetEvent(obj->windows.connect.event)) { ZeroMemory(&obj->windows.connect.overlapped, sizeof(obj->windows.connect.overlapped)); obj->windows.connect.overlapped.hEvent = obj->windows.connect.event; if (ConnectNamedPipe(obj->input.descriptor, &obj->windows.connect.overlapped)) { if (doWindowsPipeConnected(obj)) { return 1; } } else { DWORD error = GetLastError(); if (error == ERROR_PIPE_CONNECTED) { if (doWindowsPipeConnected(obj)) { return 1; } } else if (error == ERROR_IO_PENDING) { if (asyncMonitorFileInput(&obj->windows.connect.monitor, obj->windows.connect.event, handleWindowsPipeConnected, obj)) { return 1; } } else { logWindowsError(error, "ConnectNamedPipe"); } } } else { logWindowsSystemError("ResetEvent"); } return 0; }
int serialGetAttributes (SerialDevice *serial, SerialAttributes *attributes) { attributes->DCBlength = sizeof(serial->currentAttributes); if (GetCommState(serial->package.fileHandle, attributes)) return 1; logWindowsSystemError("GetCommState"); return 0; }
void processSpeechInput (SpeechSynthesizer *spk) { #if defined(__MINGW32__) if (speechInputHandle != INVALID_HANDLE_VALUE) { if (speechInputConnected || (speechInputConnected = ConnectNamedPipe(speechInputHandle, NULL)) || (speechInputConnected = (GetLastError() == ERROR_PIPE_CONNECTED))) { char buffer[0X1000]; DWORD count; if (ReadFile(speechInputHandle, buffer, sizeof(buffer), &count, NULL)) { if (count) sayCharacters(spk, buffer, count, 0); } else { DWORD error = GetLastError(); if (error != ERROR_NO_DATA) { speechInputConnected = 0; DisconnectNamedPipe(speechInputHandle); if (error != ERROR_BROKEN_PIPE) logWindowsSystemError("speech input FIFO read"); } } } } #elif defined(S_ISFIFO) if (speechInputDescriptor != -1) { char buffer[0X1000]; int count = read(speechInputDescriptor, buffer, sizeof(buffer)); if (count > 0) sayCharacters(spk, buffer, count, 0); } #endif /* process speech input */ }
int serialMonitorWaitLines (SerialDevice *serial) { DWORD event; if (WaitCommEvent(serial->package.fileHandle, &event, NULL)) return 1; logWindowsSystemError("WaitCommEvent"); return 0; }
static int acceptNamedPipeConnection (const char *path) { HANDLE h; OVERLAPPED overl = {0, 0, {{0, 0}}, NULL}; DWORD res; int attempts = 0; if ((h = CreateNamedPipe(path, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE, 1, 0, 0, 0, NULL)) == INVALID_HANDLE_VALUE) { logWindowsSystemError("CreateNamedPipe"); return -1; } overl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); if (!ConnectNamedPipe(h, &overl)) { switch (GetLastError()) { case ERROR_IO_PENDING: while ((res = WaitForSingleObject(overl.hEvent, 10000)) != WAIT_OBJECT_0) { if (res == WAIT_TIMEOUT) { ++attempts; logMessage(LOG_DEBUG, "no connection yet, still waiting (%d).", attempts); } else { logWindowsSystemError("ConnectNamedPipe"); CloseHandle(h); h = (HANDLE) -1; break; } } case ERROR_PIPE_CONNECTED: break; default: logWindowsSystemError("ConnectNamedPipe"); CloseHandle(h); h = (HANDLE) -1; break; } } CloseHandle(overl.hEvent); operations = &namedPipeOperationsEntry; return (int)h; }
int findSharedSymbol (void *object, const char *symbol, void *pointerAddress) { void **address = pointerAddress; if ((*address = GetProcAddress((HMODULE) object, symbol))) return 1; logWindowsSystemError("looking up symbol in library"); return 0; }
int enableSpeechInput (const char *name) { const char *directory; onProgramExit("speech-input", exitSpeechInput, NULL); #if defined(__MINGW32__) directory = "//./pipe"; #else /* set speech input directory */ directory = "."; #endif /* set speech input directory */ if ((speechInputPath = makePath(directory, name))) { #if defined(__MINGW32__) if ((speechInputHandle = CreateNamedPipe(speechInputPath, PIPE_ACCESS_INBOUND, PIPE_TYPE_MESSAGE|PIPE_READMODE_MESSAGE|PIPE_NOWAIT, 1, 0, 0, 0, NULL)) != INVALID_HANDLE_VALUE) { logMessage(LOG_DEBUG, "speech input pipe created: %s: handle=%u", speechInputPath, (unsigned)speechInputHandle); return 1; } else { logWindowsSystemError("CreateNamedPipe"); } #elif defined(S_ISFIFO) int result = mkfifo(speechInputPath, 0); if ((result == -1) && (errno == EEXIST)) { struct stat fifo; if ((lstat(speechInputPath, &fifo) != -1) && S_ISFIFO(fifo.st_mode)) result = 0; } if (result != -1) { chmod(speechInputPath, S_IRUSR|S_IWUSR|S_IWGRP|S_IWOTH); if ((speechInputDescriptor = open(speechInputPath, O_RDONLY|O_NONBLOCK)) != -1) { logMessage(LOG_DEBUG, "speech input FIFO created: %s: fd=%d", speechInputPath, speechInputDescriptor); return 1; } else { logMessage(LOG_ERR, "cannot open speech input FIFO: %s: %s", speechInputPath, strerror(errno)); } unlink(speechInputPath); } else { logMessage(LOG_ERR, "cannot create speech input FIFO: %s: %s", speechInputPath, strerror(errno)); } #endif /* enable speech input */ free(speechInputPath); speechInputPath = NULL; } return 0; }
static int testMonitor (const MonitorEntry *monitor, int *error) { DWORD result = WaitForSingleObject(*monitor, 0); if (result == WAIT_OBJECT_0) return 1; if (result == WAIT_FAILED) { logWindowsSystemError("WaitForSingleObject"); } return 0; }
int prepareHostCommandStream (HostCommandStream *hcs, void *data) { SECURITY_ATTRIBUTES attributes; ZeroMemory(&attributes, sizeof(attributes)); attributes.nLength = sizeof(attributes); attributes.bInheritHandle = TRUE; attributes.lpSecurityDescriptor = NULL; if (CreatePipe(&hcs->package.inputHandle, &hcs->package.outputHandle, &attributes, 0)) { if (SetHandleInformation(*getParentHandle(hcs), HANDLE_FLAG_INHERIT, 0)) { return 1; } else { logWindowsSystemError("SetHandleInformation"); } } else { logWindowsSystemError("CreatePipe"); } return 0; }
int installService (const char *name, const char *description) { int installed = 0; const char *const arguments[] = { getProgramPath(), NULL }; char *command = makeWindowsCommandLine(arguments); if (command) { SC_HANDLE scm = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE); if (scm) { SC_HANDLE service = CreateService(scm, name, description, SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, command, NULL, NULL, NULL, NULL, NULL); if (service) { logMessage(LOG_NOTICE, "service installed: %s", name); installed = 1; CloseServiceHandle(service); } else if (GetLastError() == ERROR_SERVICE_EXISTS) { logMessage(LOG_WARNING, "service already installed: %s", name); installed = 1; } else { logWindowsSystemError("CreateService"); } CloseServiceHandle(scm); } else { logWindowsSystemError("OpenSCManager"); } free(command); } return installed; }
int serialGetLines (SerialDevice *serial) { if (!GetCommModemStatus(serial->package.fileHandle, &serial->linesState)) { logWindowsSystemError("GetCommModemStatus"); return 0; } { DCB dcb; dcb.DCBlength = sizeof(dcb); if (!GetCommState(serial->package.fileHandle, &dcb)) { logWindowsSystemError("GetCommState"); return 0; } if (dcb.fRtsControl == RTS_CONTROL_ENABLE) serial->linesState |= SERIAL_LINE_RTS; if (dcb.fDtrControl == DTR_CONTROL_ENABLE) serial->linesState |= SERIAL_LINE_DTR; } return 1; }
int serialRegisterWaitLines (SerialDevice *serial, SerialLines lines) { DWORD eventMask = 0; if (lines & SERIAL_LINE_CTS) eventMask |= EV_CTS; if (lines & SERIAL_LINE_DSR) eventMask |= EV_DSR; if (lines & SERIAL_LINE_RNG) eventMask |= EV_RING; if (lines & SERIAL_LINE_CAR) eventMask |= EV_RLSD; if (SetCommMask(serial->package.fileHandle, eventMask)) return 1; logWindowsSystemError("SetCommMask"); return 0; }
static int readNamedPipe (int descriptor, void *buffer, int size) { { DWORD available; if (!PeekNamedPipe((HANDLE)descriptor, NULL, 0, NULL, &available, NULL)) { logWindowsSystemError("PeekNamedPipe"); return 0; } if (!available) { errno = EAGAIN; return -1; } if (available < size) size = available; } { DWORD received; OVERLAPPED overl = {0, 0, {{0, 0}}, NULL}; overl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); if (!ReadFile((HANDLE)descriptor, buffer, size, &received, &overl)) { if (GetLastError() != ERROR_IO_PENDING) { logWindowsSystemError("ReadPipe"); received = 0; } else if (!GetOverlappedResult((HANDLE)descriptor, &overl, &received, TRUE)) { logWindowsSystemError("GetOverlappedResult"); received = 0; } } CloseHandle(overl.hEvent); return received; } }
static int awaitMonitors (const MonitorGroup *monitors, int timeout) { if (monitors->count) { DWORD result = WaitForMultipleObjects(monitors->count, monitors->array, FALSE, timeout); if ((result >= WAIT_OBJECT_0) && (result < (WAIT_OBJECT_0 + monitors->count))) return 1; if (result == WAIT_FAILED) { logWindowsSystemError("WaitForMultipleObjects"); } } else { approximateDelay(timeout); } return 0; }
static int requestNamedPipeConnection (const char *path) { HANDLE h; if ((h = CreateFile(path, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE) { logWindowsSystemError("Connect to named pipe"); return -1; } operations = &namedPipeOperationsEntry; return (int)h; }
int serialConnectDevice (SerialDevice *serial, const char *device) { if ((serial->package.fileHandle = CreateFile(device, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL)) != INVALID_HANDLE_VALUE) { serial->package.pendingCharacter = -1; if (serialPrepareDevice(serial)) { logMessage(LOG_CATEGORY(SERIAL_IO), "device opened: %s: fh=%" PRIfd, device, serial->package.fileHandle); return 1; } CloseHandle(serial->package.fileHandle); } else { logWindowsSystemError("CreateFile"); logMessage(LOG_ERR, "cannot open serial device: %s", device); } return 0; }
static int retrievePeerCredentials (PeerCredentials *credentials, FileDescriptor fd) { char buffer[0X100+1]; if (GetNamedPipeHandleState(fd, NULL, NULL, NULL, NULL, buffer, sizeof(buffer))) { buffer[sizeof(buffer) - 1] = 0; if ((credentials->user = strdup(buffer))) { return 1; } } else { switch (GetLastError()) { default: logWindowsSystemError("GetNamedPipeHandleState"); case ERROR_INSUFFICIENT_BUFFER: /* buffer too small */ case ERROR_INVALID_HANDLE: /* not a named pipe */ case ERROR_CANNOT_IMPERSONATE: /* no data transferred yet */ break; } } return 0; }
static void disconnectWindowsPipe (NamedPipeObject *obj) { if (!DisconnectNamedPipe(obj->input.descriptor)) { logWindowsSystemError("DisconnectNamedPipe"); } }
const char * win_getLocale (void) { if (GetLocaleInfoExProc) { #define WIN_LOCALE_SIZE 85 WCHAR buffer[WIN_LOCALE_SIZE]; int result = GetLocaleInfoExProc(LOCALE_NAME_USER_DEFAULT, LOCALE_SNAME, buffer, WIN_LOCALE_SIZE); if (result > 0) { static char locale[WIN_LOCALE_SIZE]; const WCHAR *source = buffer; char *target = locale; do { char c = *source; if (c == '-') c = '_'; *target++ = c; } while (*source++); return locale; } else { logWindowsSystemError("GetLocaleInfoEx"); } } { DWORD langid; int result = GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ILANGUAGE | LOCALE_RETURN_NUMBER, (char *)&langid, sizeof(langid)/sizeof(TCHAR)); if (result > 0) { switch (langid) { #define DIALECT(primary,secondary,locale) case MAKELANGID(LANG_##primary, SUBLANG_##primary##_##secondary): return (locale); DIALECT(AFRIKAANS, SOUTH_AFRICA, "af_ZA"); DIALECT(ALBANIAN, ALBANIA, "sq_AL"); DIALECT(ALSATIAN, FRANCE, "gsw_FR"); DIALECT(AMHARIC, ETHIOPIA, "am_ET"); DIALECT(ARABIC, ALGERIA, "ar_DZ"); DIALECT(ARABIC, BAHRAIN, "ar_BH"); DIALECT(ARABIC, EGYPT, "ar_EG"); DIALECT(ARABIC, IRAQ, "ar_IQ"); DIALECT(ARABIC, JORDAN, "ar_JO"); DIALECT(ARABIC, KUWAIT, "ar_QW"); DIALECT(ARABIC, LEBANON, "ar_LB"); DIALECT(ARABIC, LIBYA, "ar_LY"); DIALECT(ARABIC, MOROCCO, "ar_MA"); DIALECT(ARABIC, OMAN, "ar_OM"); DIALECT(ARABIC, QATAR, "ar_QA"); DIALECT(ARABIC, SAUDI_ARABIA, "ar_SA"); DIALECT(ARABIC, SYRIA, "ar_SY"); DIALECT(ARABIC, TUNISIA, "ar_TN"); DIALECT(ARABIC, UAE, "ar_AE"); DIALECT(ARABIC, YEMEN, "ar_YE"); DIALECT(ARMENIAN, ARMENIA, "hy_AM"); DIALECT(ASSAMESE, INDIA, "as_IN"); DIALECT(AZERI, CYRILLIC, "az@cyrillic"); DIALECT(AZERI, LATIN, "az@latin"); DIALECT(BASHKIR, RUSSIA, "ba_RU"); DIALECT(BASQUE, BASQUE, "eu_XX"); DIALECT(BELARUSIAN, BELARUS, "be_BY"); DIALECT(BENGALI, BANGLADESH, "bn_HD"); DIALECT(BENGALI, INDIA, "bn_IN"); DIALECT(BOSNIAN, BOSNIA_HERZEGOVINA_CYRILLIC, "bs_BA@cyrillic"); DIALECT(BOSNIAN, BOSNIA_HERZEGOVINA_LATIN, "bs_BA@latin"); DIALECT(BRETON, FRANCE, "br_FR"); DIALECT(BULGARIAN, BULGARIA, "bg_BG"); DIALECT(CATALAN, CATALAN, "ca_XX"); DIALECT(CHINESE, HONGKONG, "zh_HK"); DIALECT(CHINESE, MACAU, "zh_MO"); DIALECT(CHINESE, SIMPLIFIED, "zh_CN"); DIALECT(CHINESE, SINGAPORE, "zh_SG"); DIALECT(CHINESE, TRADITIONAL, "zh_TW"); DIALECT(CORSICAN, FRANCE, "co_FR"); DIALECT(CROATIAN, BOSNIA_HERZEGOVINA_LATIN, "hr_BA@latin"); DIALECT(CROATIAN, CROATIA, "hr_HR"); DIALECT(CZECH, CZECH_REPUBLIC, "cs_CZ"); DIALECT(DANISH, DENMARK, "da_DK"); DIALECT(DIVEHI, MALDIVES, "dv_MV"); DIALECT(DUTCH, BELGIAN, "nl_BE"); DIALECT(DUTCH, NETHERLANDS, "nl_NL"); DIALECT(ENGLISH, AUS, "en_AU"); DIALECT(ENGLISH, BELIZE, "en_BZ"); DIALECT(ENGLISH, CAN, "en_CA"); DIALECT(ENGLISH, CARIBBEAN, "en_XX"); DIALECT(ENGLISH, INDIA, "en_IN"); DIALECT(ENGLISH, IRELAND, "en_IE"); DIALECT(ENGLISH, JAMAICA, "en_JM"); DIALECT(ENGLISH, MALAYSIA, "en_MY"); DIALECT(ENGLISH, NZ, "en_NZ"); DIALECT(ENGLISH, PHILIPPINES, "en_PH"); DIALECT(ENGLISH, SINGAPORE, "en_SG"); DIALECT(ENGLISH, SOUTH_AFRICA, "en_ZA"); DIALECT(ENGLISH, TRINIDAD, "en_TT"); DIALECT(ENGLISH, UK, "en_GB"); DIALECT(ENGLISH, US, "en_US"); DIALECT(ENGLISH, ZIMBABWE, "en_ZW"); DIALECT(ESTONIAN, ESTONIA, "et_EE"); DIALECT(FAEROESE, FAROE_ISLANDS, "fo_FO"); DIALECT(FILIPINO, PHILIPPINES, "fil_PH"); DIALECT(FINNISH, FINLAND, "fi_FI"); DIALECT(FRENCH, BELGIAN, "fr_BE"); DIALECT(FRENCH, CANADIAN, "fr_CA"); DIALECT(FRENCH, FRANCE, "fr_FR"); DIALECT(FRENCH, LUXEMBOURG, "fr_LU"); DIALECT(FRENCH, MONACO, "fr_MC"); DIALECT(FRENCH, SWISS, "fr_CH"); DIALECT(FRISIAN, NETHERLANDS, "fy_NL"); DIALECT(GALICIAN, GALICIAN, "gl_ES"); DIALECT(GEORGIAN, GEORGIA, "ka_GE"); DIALECT(GERMAN, AUSTRIAN, "de_AT"); DIALECT(GERMAN, GERMANY, "de_DE"); DIALECT(GERMAN, LIECHTENSTEIN, "de_LI"); DIALECT(GERMAN, LUXEMBOURG, "de_LU"); DIALECT(GERMAN, SWISS, "de_CH"); DIALECT(GREEK, GREECE, "el_GR"); DIALECT(GREENLANDIC, GREENLAND, "kl_GL"); DIALECT(GUJARATI, INDIA, "gu_IN"); DIALECT(HAUSA, NIGERIA, "ha_NG"); DIALECT(HEBREW, ISRAEL, "he_IL"); DIALECT(HINDI, INDIA, "hi_IN"); DIALECT(HUNGARIAN, HUNGARY, "hu_HU"); DIALECT(ICELANDIC, ICELAND, "is_IS"); DIALECT(IGBO, NIGERIA, "ig_NG"); DIALECT(INDONESIAN, INDONESIA, "id_ID"); DIALECT(INUKTITUT, CANADA, "iu_CA"); DIALECT(IRISH, IRELAND, "ga_IE"); DIALECT(ITALIAN, ITALY, "it_IT"); DIALECT(ITALIAN, SWISS, "it_CH"); DIALECT(JAPANESE, JAPAN, "ja_JP"); DIALECT(KASHMIRI, INDIA, "ks_IN"); DIALECT(KAZAK, KAZAKHSTAN, "kk_KZ"); DIALECT(KHMER, CAMBODIA, "km_KH"); DIALECT(KICHE, GUATEMALA, "quc_GT"); DIALECT(KINYARWANDA, RWANDA, "rw_RW"); DIALECT(KONKANI, INDIA, "kok_IN"); DIALECT(KOREAN, KOREA, "ko_KR"); DIALECT(KYRGYZ, KYRGYZSTAN, "ky_KG"); DIALECT(LAO, LAO_PDR, "lo_LA"); DIALECT(LATVIAN, LATVIA, "lv_LV"); DIALECT(LITHUANIAN, LITHUANIA, "lt_LT"); DIALECT(LOWER_SORBIAN, GERMANY, "dsb_DE"); DIALECT(LUXEMBOURGISH, LUXEMBOURG, "lb_LU"); DIALECT(MACEDONIAN, MACEDONIA, "mk_MK"); DIALECT(MALAY, BRUNEI_DARUSSALAM, "ms_BN"); DIALECT(MALAY, MALAYSIA, "ms_MY"); DIALECT(MALAYALAM, INDIA, "ml_IN"); DIALECT(MALTESE, MALTA, "mt_MT"); DIALECT(MAORI, NEW_ZEALAND, "mi_NZ"); DIALECT(MAPUDUNGUN, CHILE, "arn_CL"); DIALECT(MARATHI, INDIA, "mr_IN"); DIALECT(MOHAWK, MOHAWK, "moh"); DIALECT(MONGOLIAN, CYRILLIC_MONGOLIA, "mn_MN@cyrillic"); DIALECT(MONGOLIAN, PRC, "mn_CN"); DIALECT(NEPALI, INDIA, "ne_IN"); DIALECT(NEPALI, NEPAL, "ne_NP"); DIALECT(NORWEGIAN, BOKMAL, "nb_NO"); DIALECT(NORWEGIAN, NYNORSK, "nn_NO"); DIALECT(OCCITAN, FRANCE, "oc_FR"); DIALECT(ORIYA, INDIA, "or_IN"); DIALECT(PASHTO, AFGHANISTAN, "ps_AF"); DIALECT(PERSIAN, IRAN, "fa_IR"); DIALECT(POLISH, POLAND, "pl_PL"); DIALECT(PORTUGUESE, BRAZILIAN, "pt_BR"); DIALECT(PORTUGUESE, PORTUGAL, "pt_PT"); DIALECT(PUNJABI, INDIA, "pa_IN"); #ifdef SUBLANG_PUNJABI_PAKISTAN DIALECT(PUNJABI, PAKISTAN, "pa_PK"); #endif /* SUBLANG_PUNJABI_PAKISTAN */ DIALECT(QUECHUA, BOLIVIA, "qu_BO"); DIALECT(QUECHUA, ECUADOR, "qu_EC"); DIALECT(QUECHUA, PERU, "qu_PE"); #ifdef SUBLANG_ROMANIAN_MOLDOVA DIALECT(ROMANIAN, MOLDOVA, "ro_MD"); #endif /* SUBLANG_ROMANIAN_MOLDOVA */ DIALECT(ROMANIAN, ROMANIA, "ro_RO"); DIALECT(RUSSIAN, RUSSIA, "ru_RU"); DIALECT(SAMI, LULE_NORWAY, "smj_NO"); DIALECT(SAMI, LULE_SWEDEN, "smj_SE"); DIALECT(SAMI, NORTHERN_FINLAND, "sme_FI"); DIALECT(SAMI, NORTHERN_NORWAY, "sme_NO"); DIALECT(SAMI, NORTHERN_SWEDEN, "sme_SE"); DIALECT(SAMI, SOUTHERN_NORWAY, "sma_NO"); DIALECT(SAMI, SOUTHERN_SWEDEN, "sma_SE"); DIALECT(SANSKRIT, INDIA, "sa_IN"); DIALECT(SERBIAN, BOSNIA_HERZEGOVINA_CYRILLIC, "sr_BA@cyrillic"); DIALECT(SERBIAN, BOSNIA_HERZEGOVINA_LATIN, "sr_BA@latin"); DIALECT(SERBIAN, CYRILLIC, "sr@cyrillic"); DIALECT(SERBIAN, LATIN, "sr@latin"); DIALECT(SINDHI, AFGHANISTAN, "sd_AF"); DIALECT(SINHALESE, SRI_LANKA, "si_LK"); DIALECT(SLOVAK, SLOVAKIA, "sk_SK"); DIALECT(SLOVENIAN, SLOVENIA, "sl_SI"); DIALECT(SOTHO, NORTHERN_SOUTH_AFRICA, "st_XX"); DIALECT(SPANISH, ARGENTINA, "es_AR"); DIALECT(SPANISH, BOLIVIA, "es_BO"); DIALECT(SPANISH, CHILE, "es_CL"); DIALECT(SPANISH, COLOMBIA, "es_CO"); DIALECT(SPANISH, COSTA_RICA, "es_CR"); DIALECT(SPANISH, DOMINICAN_REPUBLIC, "es_DO"); DIALECT(SPANISH, ECUADOR, "es_EC"); DIALECT(SPANISH, EL_SALVADOR, "es_SV"); DIALECT(SPANISH, GUATEMALA, "es_GT"); DIALECT(SPANISH, HONDURAS, "es_HN"); DIALECT(SPANISH, MEXICAN, "es_MX"); DIALECT(SPANISH, MODERN, "es_XX"); DIALECT(SPANISH, NICARAGUA, "es_NI"); DIALECT(SPANISH, PANAMA, "es_PA"); DIALECT(SPANISH, PARAGUAY, "es_PY"); DIALECT(SPANISH, PERU, "es_PE"); DIALECT(SPANISH, PUERTO_RICO, "es_PR"); DIALECT(SPANISH, SPAIN, "es_ES"); DIALECT(SPANISH, URUGUAY, "es_UY"); DIALECT(SPANISH, US, "es_US"); DIALECT(SPANISH, VENEZUELA, "es_VE"); DIALECT(SWEDISH, FINLAND, "sv_FI"); DIALECT(SWEDISH, SWEDEN, "sv_SE"); DIALECT(SYRIAC, TURKEY, "syr_TR"); DIALECT(TAMAZIGHT, ALGERIA_LATIN, "ber_DZ@latin"); DIALECT(TAMIL, INDIA, "ta_IN"); DIALECT(TATAR, RUSSIA, "tt_RU"); DIALECT(TELUGU, INDIA, "te_IN"); DIALECT(THAI, THAILAND, "th_TH"); DIALECT(TIBETAN, BHUTAN, "bo_BT"); DIALECT(TIBETAN, PRC, "bo_CN"); DIALECT(TIGRIGNA, ERITREA, "ti_ER"); DIALECT(TSWANA, SOUTH_AFRICA, "tn_ZA"); DIALECT(TURKISH, TURKEY, "tr_TR"); DIALECT(UIGHUR, PRC, "ug_CN"); DIALECT(UKRAINIAN, UKRAINE, "uk_UA"); //DIALECT(UPPER_SORBIAN, GERMANY, "hsb_DE"); DIALECT(URDU, INDIA, "ur_IN"); DIALECT(URDU, PAKISTAN, "ur_PK"); DIALECT(UZBEK, CYRILLIC, "uz@cyrillic"); DIALECT(UZBEK, LATIN, "uz@latin"); DIALECT(VIETNAMESE, VIETNAM, "vi_VN"); DIALECT(WELSH, UNITED_KINGDOM, "cy_GB"); DIALECT(WOLOF, SENEGAL, "fy_SN"); DIALECT(XHOSA, SOUTH_AFRICA, "xh_ZA"); DIALECT(YAKUT, RUSSIA, "sah_RU"); DIALECT(YI, PRC, "ii_CN"); DIALECT(YORUBA, NIGERIA, "yo_NG"); DIALECT(ZULU, SOUTH_AFRICA, "zu_ZA"); #undef DIALECT } switch (PRIMARYLANGID(langid)) { #define LANGUAGE(primary,locale) case LANG_##primary: return (locale); LANGUAGE(AFRIKAANS, "af"); LANGUAGE(ALBANIAN, "sq"); LANGUAGE(ALSATIAN, "gsw"); LANGUAGE(AMHARIC, "am"); LANGUAGE(ARABIC, "ar"); LANGUAGE(ARMENIAN, "hy"); LANGUAGE(ASSAMESE, "as"); LANGUAGE(AZERI, "az"); LANGUAGE(BASHKIR, "ba"); LANGUAGE(BASQUE, "eu"); LANGUAGE(BELARUSIAN, "be"); LANGUAGE(BENGALI, "bn"); LANGUAGE(BOSNIAN, "bs"); LANGUAGE(BOSNIAN_NEUTRAL, "bs"); LANGUAGE(BRETON, "br"); LANGUAGE(BULGARIAN, "bg"); LANGUAGE(CATALAN, "ca"); LANGUAGE(CHINESE, "zh"); LANGUAGE(CORSICAN, "co"); //LANGUAGE(CROATIAN, "hr"); LANGUAGE(CZECH, "cs"); LANGUAGE(DANISH, "da"); LANGUAGE(DARI, "gbz"); LANGUAGE(DIVEHI, "dv"); LANGUAGE(DUTCH, "nl"); LANGUAGE(ENGLISH, "en"); LANGUAGE(ESTONIAN, "et"); LANGUAGE(FAEROESE, "fo"); LANGUAGE(FILIPINO, "fil"); LANGUAGE(FINNISH, "fi"); LANGUAGE(FRENCH, "fr"); LANGUAGE(FRISIAN, "fy"); LANGUAGE(GALICIAN, "gl"); LANGUAGE(GEORGIAN, "ka"); LANGUAGE(GERMAN, "de"); LANGUAGE(GREEK, "el"); LANGUAGE(GREENLANDIC, "kl"); LANGUAGE(GUJARATI, "gu"); LANGUAGE(HAUSA, "ha"); LANGUAGE(HEBREW, "he"); LANGUAGE(HINDI, "hi"); LANGUAGE(HUNGARIAN, "hu"); LANGUAGE(ICELANDIC, "is"); LANGUAGE(IGBO, "ig"); LANGUAGE(INDONESIAN, "id"); LANGUAGE(INUKTITUT, "iu"); LANGUAGE(IRISH, "ga"); LANGUAGE(ITALIAN, "it"); LANGUAGE(JAPANESE, "ja"); LANGUAGE(KANNADA, "kn"); LANGUAGE(KASHMIRI, "ks"); LANGUAGE(KAZAK, "kk"); LANGUAGE(KHMER, "km"); LANGUAGE(KICHE, "quc"); LANGUAGE(KINYARWANDA, "rw"); LANGUAGE(KONKANI, "kok"); LANGUAGE(KOREAN, "ko"); LANGUAGE(KYRGYZ, "ky"); LANGUAGE(LAO, "lo"); LANGUAGE(LATVIAN, "lv"); LANGUAGE(LITHUANIAN, "lt"); LANGUAGE(LOWER_SORBIAN, "dsb"); LANGUAGE(LUXEMBOURGISH, "lb"); LANGUAGE(MACEDONIAN, "mk"); LANGUAGE(MALAGASY, "mg"); LANGUAGE(MALAY, "ms"); LANGUAGE(MALAYALAM, "ml"); LANGUAGE(MALTESE, "mt"); LANGUAGE(MANIPURI, "mni"); LANGUAGE(MAORI, "mi"); LANGUAGE(MAPUDUNGUN, "arn"); LANGUAGE(MARATHI, "mr"); LANGUAGE(MOHAWK, "moh"); LANGUAGE(MONGOLIAN, "mn"); LANGUAGE(NEPALI, "ne"); LANGUAGE(NORWEGIAN, "no"); LANGUAGE(OCCITAN, "oc"); LANGUAGE(ORIYA, "or"); LANGUAGE(PASHTO, "ps"); LANGUAGE(PERSIAN, "fa"); LANGUAGE(POLISH, "pl"); LANGUAGE(PORTUGUESE, "pt"); LANGUAGE(PUNJABI, "pa"); LANGUAGE(QUECHUA, "qu"); LANGUAGE(ROMANIAN, "ro"); LANGUAGE(RUSSIAN, "ru"); LANGUAGE(SAMI, "se"); LANGUAGE(SANSKRIT, "sa"); //LANGUAGE(SERBIAN, "sr"); LANGUAGE(SERBIAN_NEUTRAL, "sr"); LANGUAGE(SINDHI, "sd"); LANGUAGE(SINHALESE, "si"); LANGUAGE(SLOVAK, "sk"); LANGUAGE(SLOVENIAN, "sl"); LANGUAGE(SOTHO, "st"); LANGUAGE(SPANISH, "es"); LANGUAGE(SWAHILI, "sw"); LANGUAGE(SWEDISH, "sv"); LANGUAGE(SYRIAC, "syr"); LANGUAGE(TAMAZIGHT, "ber"); LANGUAGE(TAMIL, "ta"); LANGUAGE(TATAR, "tt"); LANGUAGE(TELUGU, "te"); LANGUAGE(THAI, "th"); LANGUAGE(TIBETAN, "bo"); LANGUAGE(TIGRIGNA, "ti"); LANGUAGE(TSWANA, "tn"); LANGUAGE(TURKISH, "tr"); LANGUAGE(UIGHUR, "ug"); LANGUAGE(UKRAINIAN, "uk"); //LANGUAGE(UPPER_SORBIAN, "hsb"); LANGUAGE(URDU, "ur"); LANGUAGE(UZBEK, "uz"); LANGUAGE(VIETNAMESE, "vi"); LANGUAGE(WELSH, "cy"); LANGUAGE(WOLOF, "fy"); LANGUAGE(XHOSA, "xh"); LANGUAGE(YAKUT, "sah"); LANGUAGE(YI, "ii"); LANGUAGE(YORUBA, "yo"); LANGUAGE(ZULU, "zu"); #undef LANGUAGE } } else { logWindowsSystemError("GetLocaleInfo"); } } return "xx"; }
void setCurrentTime (const TimeValue *now) { #if defined(HAVE_CLOCK_SETTIME) && defined(CLOCK_REALTIME) const struct timespec ts = { .tv_sec = now->seconds, .tv_nsec = now->nanoseconds }; if (clock_settime(CLOCK_REALTIME, &ts) == -1) { logSystemError("clock_settime"); } #elif defined(HAVE_SETTIMEOFDAY) const struct timeval tv = { .tv_sec = now->seconds, .tv_usec = now->nanoseconds / NSECS_PER_USEC }; if (settimeofday(&tv, NULL) == -1) { logSystemError("settimeofday"); } #elif defined(__MINGW32__) TimeComponents components; expandTimeValue(now, &components); SYSTEMTIME time = { .wYear = components.year, .wMonth = components.month + 1, .wDay = components.day + 1, .wHour = components.hour, .wMinute = components.minute, .wSecond = components.second, .wMilliseconds = now->nanoseconds / NSECS_PER_MSEC }; if (!SetLocalTime(&time)) { logWindowsSystemError("SetLocalTime"); } #elif defined(HAVE_STIME) const time_t seconds = now->seconds; if (stime(&seconds) == -1) { logSystemError("stime"); } #else /* set current time */ #warning set current time not supported on this platform #endif /* get current time */ } void makeTimeValue (TimeValue *value, const TimeComponents *components) { value->nanoseconds = components->nanosecond; #if defined(GRUB_RUNTIME) value->seconds = 0; #else /* make seconds */ struct tm time = { .tm_year = components->year - 1900, .tm_mon = components->month, .tm_mday = components->day + 1, .tm_hour = components->hour, .tm_min = components->minute, .tm_sec = components->second, .tm_isdst = -1 }; value->seconds = mktime(&time); #endif /* make seconds */ } void expandTimeValue (const TimeValue *value, TimeComponents *components) { time_t seconds = value->seconds; struct tm time; localtime_r(&seconds, &time); components->nanosecond = value->nanoseconds; #if defined(GRUB_RUNTIME) components->year = time.tm.year; components->month = time.tm.month - 1; components->day = time.tm.day - 1; components->hour = time.tm.hour; components->minute = time.tm.minute; components->second = time.tm.second; #else /* expand seconds */ components->year = time.tm_year + 1900; components->month = time.tm_mon; components->day = time.tm_mday - 1; components->hour = time.tm_hour; components->minute = time.tm_min; components->second = time.tm_sec; #endif /* expand seconds */ } size_t formatSeconds (char *buffer, size_t size, const char *format, int32_t seconds) { time_t time = seconds; struct tm description; localtime_r(&time, &description); return strftime(buffer, size, format, &description); } void normalizeTimeValue (TimeValue *time) { while (time->nanoseconds < 0) { time->seconds -= 1; time->nanoseconds += NSECS_PER_SEC; } while (time->nanoseconds >= NSECS_PER_SEC) { time->seconds += 1; time->nanoseconds -= NSECS_PER_SEC; } } void adjustTimeValue (TimeValue *time, int milliseconds) { TimeValue amount = { .seconds = milliseconds / MSECS_PER_SEC, .nanoseconds = (milliseconds % MSECS_PER_SEC) * NSECS_PER_MSEC }; normalizeTimeValue(time); normalizeTimeValue(&amount); time->seconds += amount.seconds; time->nanoseconds += amount.nanoseconds; normalizeTimeValue(time); }
void unloadSharedObject (void *object) { if (!(FreeLibrary((HMODULE) object))) logWindowsSystemError("unloading library"); }
static int brl_construct (BrailleDisplay *brl, char **parameters, const char *device) { if (!allocateCommandDescriptors()) return 0; inputLength = 0; inputStart = 0; inputEnd = 0; outputLength = 0; if (isQualifiedDevice(&device, "client")) { static const ModeEntry clientModeEntry = { #ifdef AF_LOCAL requestLocalConnection, #endif /* AF_LOCAL */ #ifdef __MINGW32__ requestNamedPipeConnection, #endif /* __MINGW32__ */ requestInetConnection }; mode = &clientModeEntry; } else if (isQualifiedDevice(&device, "server")) { static const ModeEntry serverModeEntry = { #ifdef AF_LOCAL acceptLocalConnection, #endif /* AF_LOCAL */ #ifdef __MINGW32__ acceptNamedPipeConnection, #endif /* __MINGW32__ */ acceptInetConnection }; mode = &serverModeEntry; } else { unsupportedDevice(device); goto failed; } if (!*device) device = VR_DEFAULT_SOCKET; #ifdef AF_LOCAL if (device[0] == '/') { struct sockaddr_un address; if (setLocalAddress(device, &address)) { fileDescriptor = mode->getLocalConnection(&address); } } else #endif /* AF_LOCAL */ #ifdef __MINGW32__ if (device[0] == '\\') { fileDescriptor = mode->getNamedPipeConnection(device); } else { static WSADATA wsadata; if (WSAStartup(MAKEWORD(1, 1), &wsadata)) { logWindowsSystemError("socket library start"); goto failed; } } #endif /* __MINGW32__ */ { struct sockaddr_in address; if (setInetAddress(device, &address)) { fileDescriptor = mode->getInetConnection(&address); } } if (fileDescriptor != -1) { char *line = NULL; while (1) { if (line) free(line); if ((line = readCommandLine())) { const char *word; logMessage(LOG_DEBUG, "command received: %s", line); if ((word = strtok(line, inputDelimiters))) { if (testWord(word, "cells")) { if (dimensionsChanged(brl)) { free(line); return 1; } } else if (testWord(word, "quit")) { break; } else { logMessage(LOG_WARNING, "unexpected command: %s", word); } } } else { asyncWait(1000); } } if (line) free(line); close(fileDescriptor); fileDescriptor = -1; } failed: deallocateCommandDescriptors(); return 0; }
PcmDevice * openPcmDevice (int errorLevel, const char *device) { PcmDevice *pcm; MMRESULT mmres; WAVEOUTCAPS caps; int id = 0; if (*device) { if (!isInteger(&id, device) || (id < 0) || (id >= waveOutGetNumDevs())) { logMessage(errorLevel, "invalid PCM device number: %s", device); return NULL; } } if (!(pcm = malloc(sizeof(*pcm)))) { logSystemError("PCM device allocation"); return NULL; } pcm->deviceID = id; if ((waveOutGetDevCaps(pcm->deviceID, &caps, sizeof(caps))) != MMSYSERR_NOERROR) pcm->format = defaultFormat; else { logMessage(errorLevel, "PCM device %d is %s", pcm->deviceID, caps.szPname); pcm->format.wFormatTag = WAVE_FORMAT_PCM; if (caps.dwFormats & (WAVE_FORMAT_1S08 |WAVE_FORMAT_1S16 |WAVE_FORMAT_2S08 |WAVE_FORMAT_2S16 |WAVE_FORMAT_4S08 |WAVE_FORMAT_4S16)) pcm->format.nChannels = 2; else pcm->format.nChannels = 1; if (caps.dwFormats & (WAVE_FORMAT_4M08 |WAVE_FORMAT_4M16 |WAVE_FORMAT_4S08 |WAVE_FORMAT_4S16)) pcm->format.nSamplesPerSec = 44100; else if (caps.dwFormats & (WAVE_FORMAT_2M08 |WAVE_FORMAT_2M16 |WAVE_FORMAT_2S08 |WAVE_FORMAT_2S16)) pcm->format.nSamplesPerSec = 22050; else if (caps.dwFormats & (WAVE_FORMAT_1M08 |WAVE_FORMAT_1M16 |WAVE_FORMAT_1S08 |WAVE_FORMAT_1S16)) pcm->format.nSamplesPerSec = 11025; else { logMessage(errorLevel, "unknown PCM capability %#lx", caps.dwFormats); goto out; } if (caps.dwFormats & (WAVE_FORMAT_1M16 |WAVE_FORMAT_1S16 |WAVE_FORMAT_2M16 |WAVE_FORMAT_2S16 |WAVE_FORMAT_4M16 |WAVE_FORMAT_4S16)) pcm->format.wBitsPerSample = 16; else if (caps.dwFormats & (WAVE_FORMAT_1M08 |WAVE_FORMAT_1S08 |WAVE_FORMAT_2M08 |WAVE_FORMAT_2S08 |WAVE_FORMAT_4M08 |WAVE_FORMAT_4S08)) pcm->format.wBitsPerSample = 8; else { logMessage(LOG_ERR, "unknown PCM capability %#lx", caps.dwFormats); goto out; } recomputeWaveOutFormat(&pcm->format); pcm->format.cbSize = 0; } if (!(pcm->done = CreateEvent(NULL, FALSE, TRUE, NULL))) { logWindowsSystemError("creating PCM completion event"); goto out; } pcm->waveHdr = initWaveHdr; pcm->bufSize = 0; if ((mmres = waveOutOpen(&pcm->handle, pcm->deviceID, &pcm->format, (DWORD) pcm->done, 0, CALLBACK_EVENT)) != MMSYSERR_NOERROR) { LogWaveOutError(mmres, errorLevel, "opening PCM device"); goto outEvent; } return pcm; outEvent: CloseHandle(pcm->done); out: free(pcm); return NULL; }