Example #1
0
/* 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()));
}
Example #2
0
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;
}
Example #3
0
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;
}
Example #4
0
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;
}
Example #5
0
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;
}
Example #8
0
/**
 * 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
}
Example #9
0
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);
}
Example #10
0
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);
}
Example #12
0
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;
}
Example #13
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;
}
Example #14
0
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;
}
Example #16
0
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);
}
Example #17
0
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);
  }
}
Example #18
0
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;
}
Example #19
0
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;
}
Example #21
0
File: dnssrv.c Project: VoxOx/VoxOx
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;
}
Example #22
0
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);
}
Example #23
0
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;
}
Example #25
0
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);
}
Example #26
0
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;
}
Example #27
0
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);
}
Example #28
0
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);
    }
}
Example #30
0
/**
 *  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;
}