/* This could be interesting to expose in public API */ static void _g_test_watcher_add_pid (GPid pid) { static gsize started = 0; HANDLE job; if (g_once_init_enter (&started)) { JOBOBJECT_EXTENDED_LIMIT_INFORMATION info; job = CreateJobObjectW (NULL, NULL); memset (&info, 0, sizeof (info)); info.BasicLimitInformation.LimitFlags = 0x2000 /* JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE */; if (!SetInformationJobObject(job, JobObjectExtendedLimitInformation, &info, sizeof (info))) g_warning ("Can't enable JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE: %s", g_win32_error_message (GetLastError())); g_once_init_leave (&started,(gsize)job); } job = (HANDLE)started; if (!AssignProcessToJobObject(job, pid)) g_warning ("Can't assign process to job: %s", g_win32_error_message (GetLastError())); }
static BOOL CALLBACK enum_languages (HMODULE source, LPCTSTR type, LPCTSTR name, WORD language, LONG param) { HRSRC hrsrc; HGLOBAL reshandle; WORD *resp; int size; #if 0 printf ("lang=%#x ", language); if (HIWORD (type) == 0) printf ("%d ", (int) type); else printf ("%s ", type); if (HIWORD (name) == 0) printf ("%d\n", (int) name); else printf ("%s\n", name); #endif if ((hrsrc = FindResource (source, name, type)) == NULL) { fprintf (stderr, "FindResource failed: %s\n", g_win32_error_message (GetLastError ())); return TRUE; } size = SizeofResource (source, hrsrc); if ((reshandle = LoadResource (source, hrsrc)) == NULL) { fprintf (stderr, "LoadResource() failed: %s\n", g_win32_error_message (GetLastError ())); return TRUE; } if ((resp = LockResource (reshandle)) == 0) { fprintf (stderr, "LockResource() failed: %s", g_win32_error_message (GetLastError ())); return TRUE; } if (!UpdateResource ((HANDLE) param, type, name, language, resp, size)) { fprintf (stderr, "UpdateResource() failed: %s\n", g_win32_error_message (GetLastError ())); return TRUE; } return TRUE; }
static BOOL CALLBACK count_objects (const DIDEVICEOBJECTINSTANCEW *doi, void *user_data) { ControllerDXDInput *controller = (ControllerDXDInput *) user_data; HRESULT hresult; DIPROPRANGE range; if (doi->dwType & DIDFT_AXIS) { /* Set reported range to physical range, not to give upper * level software any false impression of higher accuracy. */ range.diph.dwSize = sizeof (DIPROPRANGE); range.diph.dwHeaderSize = sizeof (DIPROPHEADER); range.diph.dwObj = doi->dwType; range.diph.dwHow = DIPH_BYID; if (FAILED ((hresult = IDirectInputDevice8_GetProperty (controller->didevice8, DIPROP_PHYSICALRANGE, &range.diph)))) g_warning ("IDirectInputDevice8::GetProperty failed: %s", g_win32_error_message (hresult)); else { if (FAILED ((hresult = IDirectInputDevice8_SetProperty (controller->didevice8, DIPROP_RANGE, &range.diph)))) g_warning ("IDirectInputDevice8::SetProperty failed: %s", g_win32_error_message (hresult)); } } if (IsEqualGUID (&doi->guidType, &GUID_Button)) controller->num_buttons++; else if (IsEqualGUID (&doi->guidType, &GUID_XAxis) || IsEqualGUID (&doi->guidType, &GUID_YAxis) || IsEqualGUID (&doi->guidType, &GUID_ZAxis) || IsEqualGUID (&doi->guidType, &GUID_RxAxis) || IsEqualGUID (&doi->guidType, &GUID_RyAxis) || IsEqualGUID (&doi->guidType, &GUID_RzAxis)) controller->num_axes++; else if (IsEqualGUID (&doi->guidType, &GUID_Slider)) controller->num_sliders++; else if (IsEqualGUID (&doi->guidType, &GUID_POV)) controller->num_povs++; return DIENUM_CONTINUE; }
void error_set_win32(Error **errp, int win32_err, ErrorClass err_class, const char *fmt, ...) { Error *err; char *msg1; va_list ap; if (errp == NULL) { return; } assert(*errp == NULL); err = g_malloc0(sizeof(*err)); va_start(ap, fmt); msg1 = g_strdup_vprintf(fmt, ap); if (win32_err != 0) { char *msg2 = g_win32_error_message(win32_err); err->msg = g_strdup_printf("%s: %s (error: %x)", msg1, msg2, (unsigned)win32_err); g_free(msg2); g_free(msg1); } else { err->msg = msg1; } va_end(ap); err->err_class = err_class; if (errp == &error_abort) { error_report("%s", error_get_pretty(err)); abort(); } *errp = err; }
static gboolean ga_channel_open(GAChannel *c, GAChannelMethod method, const gchar *path) { COMMTIMEOUTS comTimeOut = {0}; gchar newpath[MAXPATHLEN] = {0}; comTimeOut.ReadIntervalTimeout = 1; if (method != GA_CHANNEL_VIRTIO_SERIAL && method != GA_CHANNEL_ISA_SERIAL) { g_critical("unsupported communication method"); return false; } if (method == GA_CHANNEL_ISA_SERIAL){ snprintf(newpath, sizeof(newpath), "\\\\.\\%s", path); }else { g_strlcpy(newpath, path, sizeof(newpath)); } c->handle = CreateFile(newpath, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL); if (c->handle == INVALID_HANDLE_VALUE) { g_critical("error opening path %s: %s", newpath, g_win32_error_message(GetLastError())); return false; } if (method == GA_CHANNEL_ISA_SERIAL && !SetCommTimeouts(c->handle,&comTimeOut)) { g_critical("error setting timeout for com port: %lu",GetLastError()); CloseHandle(c->handle); return false; } return true; }
static GIOStatus g_io_win32_msg_write (GIOChannel *channel, const gchar *buf, gsize count, gsize *bytes_written, GError **err) { GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel; MSG msg; if (count != sizeof (MSG)) { g_set_error(err, G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_INVAL, _("Incorrect message size")); /* Informative enough error message? */ return G_IO_STATUS_ERROR; } /* In case of alignment problems */ memmove (&msg, buf, sizeof (MSG)); if (!PostMessage (win32_channel->hwnd, msg.message, msg.wParam, msg.lParam)) { gchar *emsg = g_win32_error_message (GetLastError ()); g_set_error(err, G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_FAILED, emsg); g_free (emsg); return G_IO_STATUS_ERROR; } *bytes_written = sizeof (MSG); return G_IO_STATUS_NORMAL; }
static gboolean g_win32_output_stream_close (GOutputStream *stream, GCancellable *cancellable, GError **error) { GWin32OutputStream *win32_stream; BOOL res; win32_stream = G_WIN32_OUTPUT_STREAM (stream); if (!win32_stream->priv->close_handle) return TRUE; res = CloseHandle (win32_stream->priv->handle); if (!res) { int errsv = GetLastError (); gchar *emsg = g_win32_error_message (errsv); g_set_error (error, G_IO_ERROR, g_io_error_from_win32_error (errsv), _("Error closing handle: %s"), emsg); g_free (emsg); return FALSE; } return TRUE; }
/** * inf_native_socket_make_error: * @code: An error code obtained with #INF_NATIVE_SOCKET_LAST_ERROR * @error: Location to store error information. * * Converts the platform-dependent error code @code into a #GError. The * #GError will contain the same numerical value and a platform-dependent * human-readable error message. */ void inf_native_socket_make_error(int code, GError** error) { #ifdef G_OS_WIN32 gchar* error_message; error_message = g_win32_error_message(code); g_set_error( error, inf_native_socket_error_quark(), code, "%s", error_message ); g_free(error_message); #else g_set_error( error, inf_native_socket_error_quark(), code, "%s", strerror(code) ); #endif }
static void g_warning_hr (const char *msg, HRESULT hr) { char *errmsg; errmsg = g_win32_error_message (hr); g_warning ("%s: %s", msg, errmsg); g_free (errmsg); }
void _gdk_win32_api_failed (const gchar *where, const gchar *api) { gchar *msg = g_win32_error_message (GetLastError ()); g_warning ("%s: %s failed: %s", where, api, msg); g_free (msg); }
static void set_error (void) { gchar *error = g_win32_error_message (GetLastError ()); g_module_set_error (error); g_free (error); }
int main (int argc, char **argv) { HMODULE source; HANDLE target; if (argc != 3) { fprintf (stderr, "Usage: %s source target\n", argv[0]); return 1; } if ((source = LoadLibrary (argv[1])) == NULL) { fprintf (stderr, "LoadLibrary() failed: %s\n", g_win32_error_message (GetLastError ())); return 1; } if ((target = BeginUpdateResource (argv[2], TRUE)) == NULL) { fprintf (stderr, "BeginUpdateResource() failed: %s\n", g_win32_error_message (GetLastError ())); return 1; } if (EnumResourceTypes (source, enum_types, (LONG) target) == 0) { fprintf (stderr, "EnumResourceTypes() failed: %s\n", g_win32_error_message (GetLastError ())); return 1; } if (!EndUpdateResource (target, FALSE)) { fprintf (stderr, "EndUpdateResource() failed: %s\n", g_win32_error_message (GetLastError ())); return 1; } FreeLibrary (source); return 0; }
BOOL CALLBACK enum_types (HMODULE source, LPTSTR type, LONG param) { if (EnumResourceNames (source, type, enum_names, param) == 0) fprintf (stderr, "EnumResourceNames() failed: %s\n", g_win32_error_message (GetLastError ())); return TRUE; }
SpiceNamedPipe* spice_win32_user_pipe_new (gchar *name, GError **error) { SECURITY_ATTRIBUTES sa; SECURITY_DESCRIPTOR sd; PACL dacl = NULL; HANDLE pipe; SpiceNamedPipe *np = NULL; g_return_val_if_fail (name != NULL, NULL); g_return_val_if_fail (error != NULL, NULL); if (!get_user_security_attributes (&sa, &sd, &dacl)) return NULL; pipe = CreateNamedPipe (name, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED | /* FIXME: why is FILE_FLAG_FIRST_PIPE_INSTANCE needed for WRITE_DAC * (apparently needed by SetSecurityInfo). This will prevent * multiple pipe listener....?! */ FILE_FLAG_FIRST_PIPE_INSTANCE | WRITE_DAC, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT, PIPE_UNLIMITED_INSTANCES, DEFAULT_PIPE_BUF_SIZE, DEFAULT_PIPE_BUF_SIZE, 0, &sa); if (pipe == INVALID_HANDLE_VALUE) { int errsv = GetLastError (); gchar *emsg = g_win32_error_message (errsv); g_set_error (error, G_IO_ERROR, g_io_error_from_win32_error (errsv), "Error CreateNamedPipe(): %s", emsg); g_free (emsg); goto end; } /* lower integrity on Vista/Win7+ */ if ((LOBYTE (g_win32_get_windows_version()) > 0x05 || LOWORD (g_win32_get_windows_version()) > 0x0105) && !spice_win32_set_low_integrity (pipe, error)) goto end; np = SPICE_NAMED_PIPE (g_initable_new (SPICE_TYPE_NAMED_PIPE, NULL, error, "handle", pipe, NULL)); end: LocalFree (dacl); return np; }
static const char * gai_strerror (int error_code) { gchar *msg = g_win32_error_message (error_code); GQuark quark = g_quark_from_string (msg); const gchar *retval = g_quark_to_string (quark); g_free (msg); return retval; }
static void log_error(const gchar *message_prefix, gint error_code) { #ifdef G_OS_WIN32 error_code = error_code == -1 ? WSAGetLastError(): error_code; gchar *error_message = g_win32_error_message(error_code); #else error_code = error_code == -1 ? errno: error_code; gchar *error_message = g_strdup(g_strerror(error_code)); #endif g_warning("%s: %d: %s", message_prefix, error_code, error_message); g_free(error_message); }
static void gdip_set_error_from_hresult (GError **error, gint code, HRESULT hr, const char *format) { gchar *msg; msg = g_win32_error_message (hr); if (msg) { g_set_error (error, GDK_PIXBUF_ERROR, code, format, msg); g_free (msg); } }
GWakeup * g_wakeup_new (void) { HANDLE wakeup; wakeup = CreateEvent (NULL, TRUE, FALSE, NULL); if (wakeup == NULL) g_error ("Cannot create event for GWakeup: %s", g_win32_error_message (GetLastError ())); return (GWakeup *) wakeup; }
static void init_reset_sockets (GIOWin32Channel *channel) { struct sockaddr_in local, local2, server; int len; channel->reset_send = (gint) socket (AF_INET, SOCK_DGRAM, 0); if (channel->reset_send == INVALID_SOCKET) { g_warning (G_STRLOC ": Error creating reset_send socket: %s\n", g_win32_error_message (WSAGetLastError ())); } local.sin_family = AF_INET; local.sin_port = 0; local.sin_addr.s_addr = htonl (INADDR_LOOPBACK); if (bind (channel->reset_send, (struct sockaddr *)&local, sizeof (local)) == SOCKET_ERROR) { g_warning (G_STRLOC ": Error binding to reset_send socket: %s\n", g_win32_error_message (WSAGetLastError ())); } local2.sin_family = AF_INET; local2.sin_port = 0; local2.sin_addr.s_addr = htonl (INADDR_LOOPBACK); channel->reset_recv = (gint) socket (AF_INET, SOCK_DGRAM, 0); if (channel->reset_recv == INVALID_SOCKET) { g_warning (G_STRLOC ": Error creating reset_recv socket: %s\n", g_win32_error_message (WSAGetLastError ())); } if (bind (channel->reset_recv, (struct sockaddr *)&local2, sizeof (local)) == SOCKET_ERROR) { g_warning (G_STRLOC ": Error binding to reset_recv socket: %s\n", g_win32_error_message (WSAGetLastError ())); } len = sizeof (local2); if (getsockname (channel->reset_recv, (struct sockaddr *)&local2, &len) == SOCKET_ERROR) { g_warning (G_STRLOC ": Error getsockname with reset_recv socket: %s\n", g_win32_error_message (WSAGetLastError ())); } memset (&server, 0, sizeof (server)); server.sin_addr.s_addr = htonl (INADDR_LOOPBACK); server.sin_family = AF_INET; server.sin_port = local2.sin_port; if (connect (channel->reset_send, (struct sockaddr *)&server, sizeof (server)) == SOCKET_ERROR) { g_warning (G_STRLOC ": connect to reset_recv socket: %s\n", g_win32_error_message (WSAGetLastError ())); } }
char* wgaim_install_dir(void) { HMODULE hmod; char* buf; hmod = GetModuleHandle(NULL); if( hmod == 0 ) { buf = g_win32_error_message( GetLastError() ); gaim_debug(GAIM_DEBUG_ERROR, "wgaim", "GetModuleHandle error: %s\n", buf); g_free(buf); return NULL; } if(GetModuleFileName( hmod, (char*)&install_dir, MAXPATHLEN ) == 0) { buf = g_win32_error_message( GetLastError() ); gaim_debug(GAIM_DEBUG_ERROR, "wgaim", "GetModuleFileName error: %s\n", buf); g_free(buf); return NULL; } buf = g_path_get_dirname( install_dir ); strcpy( (char*)&install_dir, buf ); g_free( buf ); return (char*)&install_dir; }
static gpointer res_thread(gpointer data) { PDNS_RECORD dr = NULL; int type = DNS_TYPE_SRV; DNS_STATUS ds; GaimSrvQueryData *query_data = data; ds = MyDnsQuery_UTF8(query_data->query, type, DNS_QUERY_STANDARD, NULL, &dr, NULL); if (ds != ERROR_SUCCESS) { gchar *msg = g_win32_error_message(ds); query_data->error_message = g_strdup_printf("Couldn't look up SRV record. %s (%lu).\n", msg, ds); g_free(msg); } else { PDNS_RECORD dr_tmp; GSList *lst = NULL; DNS_SRV_DATA *srv_data; GaimSrvResponse *srvres; for (dr_tmp = dr; dr_tmp != NULL; dr_tmp = dr_tmp->pNext) { /* Discard any incorrect entries. I'm not sure if this is necessary */ if (dr_tmp->wType != type || strcmp(dr_tmp->pName, query_data->query) != 0) { continue; } srv_data = &dr_tmp->Data.SRV; srvres = g_new0(GaimSrvResponse, 1); strncpy(srvres->hostname, srv_data->pNameTarget, 255); srvres->hostname[255] = '\0'; srvres->pref = srv_data->wPriority; srvres->port = srv_data->wPort; srvres->weight = srv_data->wWeight; lst = g_slist_insert_sorted(lst, srvres, responsecompare); } MyDnsRecordListFree(dr, DnsFreeRecordList); query_data->results = lst; } /* back to main thread */ /* Note: this should *not* be attached to query_data->handle - it will cause leakage */ g_idle_add(res_main_thread_cb, query_data); g_thread_exit(NULL); return NULL; }
static void create_thread (GIOWin32Channel *channel, GIOCondition condition, unsigned (__stdcall *thread) (void *parameter)) { HANDLE thread_handle; thread_handle = (HANDLE) _beginthreadex (NULL, 0, thread, channel, 0, &channel->thread_id); if (thread_handle == 0) g_warning (G_STRLOC ": Error creating reader thread: %s", g_strerror (errno)); else if (!CloseHandle (thread_handle)) g_warning (G_STRLOC ": Error closing thread handle: %s\n", g_win32_error_message (GetLastError ())); WaitForSingleObject (channel->space_avail_event, INFINITE); }
gboolean spice_win32_set_low_integrity (void* handle, GError **error) { g_return_val_if_fail (handle != NULL, FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); /* see also http://msdn.microsoft.com/en-us/library/bb625960.aspx */ PSECURITY_DESCRIPTOR psd = NULL; PACL psacl = NULL; BOOL sacl_present = FALSE; BOOL sacl_defaulted = FALSE; char *emsg; int errsv; gboolean success = FALSE; if (!ConvertStringSecurityDescriptorToSecurityDescriptor ("S:(ML;;NW;;;LW)", SDDL_REVISION_1, &psd, NULL)) goto failed; if (!GetSecurityDescriptorSacl (psd, &sacl_present, &psacl, &sacl_defaulted)) goto failed; if (SetSecurityInfo (handle, SE_KERNEL_OBJECT, LABEL_SECURITY_INFORMATION, NULL, NULL, NULL, psacl) != ERROR_SUCCESS) goto failed; success = TRUE; goto end; failed: errsv = GetLastError (); emsg = g_win32_error_message (errsv); g_set_error (error, G_IO_ERROR, g_io_error_from_win32_error (errsv), "Error setting integrity: %s", emsg); g_free (emsg); end: if (psd != NULL) LocalFree (psd); return success; }
static gssize g_win32_input_stream_read (GInputStream *stream, void *buffer, gsize count, GCancellable *cancellable, GError **error) { GWin32InputStream *win32_stream; BOOL res; DWORD nbytes, nread; win32_stream = G_WIN32_INPUT_STREAM (stream); if (g_cancellable_set_error_if_cancelled (cancellable, error)) return -1; if (count > G_MAXINT) nbytes = G_MAXINT; else nbytes = count; res = ReadFile (win32_stream->priv->handle, buffer, nbytes, &nread, NULL); if (!res) { int errsv = GetLastError (); gchar *emsg; if (errsv == ERROR_HANDLE_EOF || errsv == ERROR_BROKEN_PIPE) return 0; emsg = g_win32_error_message (errsv); g_set_error (error, G_IO_ERROR, g_io_error_from_win32_error (errsv), _("Error reading from handle: %s"), emsg); g_free (emsg); return -1; } return nread; }
void _gdk_win32_print_hpalette (HPALETTE hpal) { PALETTEENTRY *pe; gint n, npal; npal = palette_size (hpal); pe = g_new (PALETTEENTRY, npal); n = GetPaletteEntries (hpal, 0, npal, pe); if (!n) g_print ("HPALETTE %p: GetPaletteEntries failed: %s\n", hpal, g_win32_error_message (GetLastError ())); else { g_print ("HPALETTE %p: %d (%d) entries\n", hpal, n, npal); _gdk_win32_print_paletteentries (pe, n); } g_free (pe); }
gboolean gssdp_net_init (GError **error) { WSADATA wsaData = {0}; gchar *message = NULL; if (WSAStartup (MAKEWORD (2,2), &wsaData) == 0) { return TRUE; } message = g_win32_error_message (WSAGetLastError ()); g_set_error_literal (error, GSSDP_ERROR, GSSDP_ERROR_FAILED, message); g_free (message); return FALSE; }
void _gdk_win32_print_system_palette (void) { PALETTEENTRY *pe; int k; k = GetSystemPaletteEntries (_gdk_display_hdc, 0, 0, NULL); pe = g_new (PALETTEENTRY, k); k = GetSystemPaletteEntries (_gdk_display_hdc, 0, k, pe); if (!k) g_print ("GetSystemPaletteEntries failed: %s\n", g_win32_error_message (GetLastError ())); else { g_print ("System palette: %d entries\n", k); _gdk_win32_print_paletteentries (pe, k); } g_free (pe); }
static void WINAPI service_main(G_GNUC_UNUSED DWORD argc, G_GNUC_UNUSED CHAR *argv[]) { DWORD error_code; gchar* error_message; service_handle = RegisterServiceCtrlHandlerEx(service_name, service_dispatcher, NULL); if (service_handle == 0) { error_code = GetLastError(); error_message = g_win32_error_message(error_code); MPD_ERROR("RegisterServiceCtrlHandlerEx() failed: %s", error_message); } service_notify_status(SERVICE_START_PENDING); mpd_main(service_argc, service_argv); service_notify_status(SERVICE_STOPPED); }
static void create_events (GIOWin32Channel *channel) { SECURITY_ATTRIBUTES sec_attrs; sec_attrs.nLength = sizeof (SECURITY_ATTRIBUTES); sec_attrs.lpSecurityDescriptor = NULL; sec_attrs.bInheritHandle = FALSE; /* The data available event is manual reset, the space available event * is automatic reset. */ if (!(channel->data_avail_event = CreateEvent (&sec_attrs, TRUE, FALSE, NULL)) || !(channel->space_avail_event = CreateEvent (&sec_attrs, FALSE, FALSE, NULL)) || !(channel->data_avail_noticed_event = CreateEvent (&sec_attrs, FALSE, FALSE, NULL))) { gchar *emsg = g_win32_error_message (GetLastError ()); g_error ("Error creating event: %s", emsg); g_free (emsg); } }
/** * Kills a process. * * @param pid id of the process to kill. * @param error return location for error. * * On Unix, sends a SIGTERM to the process. * * On Windows, terminates the process with exit code 255 (used sometimes as "generic" * error code, or for programs terminated with Ctrl+C / Ctrl+Break). * * @return @c TRUE on success, @c FALSE on error. * * @since 1.25 **/ GEANY_API_SYMBOL gboolean spawn_kill_process(GPid pid, GError **error) { #ifdef G_OS_WIN32 if (!TerminateProcess(pid, 255)) { gchar *message = g_win32_error_message(GetLastError()); g_set_error_literal(error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED, message); g_free(message); return FALSE; } #else if (kill(pid, SIGTERM)) { g_set_error_literal(error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED, g_strerror(errno)); return FALSE; } #endif return TRUE; }