aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/programs/Xserver/hw/nxagent/Error.c
diff options
context:
space:
mode:
authorReinhard Tartler <siretart@tauware.de>2011-10-10 18:02:52 +0200
committerReinhard Tartler <siretart@tauware.de>2011-10-10 18:02:52 +0200
commit5b4ca0f93c44d7bbc8d6a3eebdd5c458e3a84c14 (patch)
treeb6f59ec830436134aaccf47aa71a070aa2ad2992 /nx-X11/programs/Xserver/hw/nxagent/Error.c
parente29a112097fa74b520ba619eb07e2e0e0a7f2f3e (diff)
parente01b9177b41f7d27a934d41fa38d550fa0026b45 (diff)
downloadnx-libs-5b4ca0f93c44d7bbc8d6a3eebdd5c458e3a84c14.tar.gz
nx-libs-5b4ca0f93c44d7bbc8d6a3eebdd5c458e3a84c14.tar.bz2
nx-libs-5b4ca0f93c44d7bbc8d6a3eebdd5c458e3a84c14.zip
Merge branch 'nxagent'
Diffstat (limited to 'nx-X11/programs/Xserver/hw/nxagent/Error.c')
-rw-r--r--nx-X11/programs/Xserver/hw/nxagent/Error.c636
1 files changed, 636 insertions, 0 deletions
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Error.c b/nx-X11/programs/Xserver/hw/nxagent/Error.c
new file mode 100644
index 000000000..43bf85900
--- /dev/null
+++ b/nx-X11/programs/Xserver/hw/nxagent/Error.c
@@ -0,0 +1,636 @@
+/**************************************************************************/
+/* */
+/* Copyright (c) 2001, 2011 NoMachine, http://www.nomachine.com/. */
+/* */
+/* NXAGENT, NX protocol compression and NX extensions to this software */
+/* are copyright of NoMachine. Redistribution and use of the present */
+/* software is allowed according to terms specified in the file LICENSE */
+/* which comes in the source distribution. */
+/* */
+/* Check http://www.nomachine.com/licensing.html for applicability. */
+/* */
+/* NX and NoMachine are trademarks of Medialogic S.p.A. */
+/* */
+/* All rights reserved. */
+/* */
+/**************************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+
+#include "os.h"
+
+#include "scrnintstr.h"
+#include "Agent.h"
+
+#include "Xlib.h"
+#include "Xproto.h"
+
+#include "Error.h"
+#include "Args.h"
+
+/*
+ * Set here the required log level.
+ */
+
+#define PANIC
+#define WARNING
+#undef TEST
+#undef DEBUG
+
+
+/*
+ * Duplicated stderr file descriptor.
+ */
+
+static int nxagentStderrDup = -1;
+
+/*
+ * Saved stderr file descriptor.
+ */
+
+static int nxagentStderrBackup = -1;
+
+/*
+ * Clients log file descriptor.
+ */
+
+static int nxagentClientsLog = -1;
+
+#define DEFAULT_STRING_LENGTH 256
+
+
+/*
+ * Clients log file name.
+ */
+
+char nxagentClientsLogName[DEFAULT_STRING_LENGTH] = { 0 };
+
+/*
+ * User's home.
+ */
+
+static char nxagentHomeDir[DEFAULT_STRING_LENGTH] = { 0 };
+
+/*
+ * NX root directory.
+ */
+
+static char nxagentRootDir[DEFAULT_STRING_LENGTH] = { 0 };
+
+/*
+ * Session log Directory.
+ */
+
+static char nxagentSessionDir[DEFAULT_STRING_LENGTH] = { 0 };
+
+char *nxagentGetClientsPath(void);
+
+static int nxagentPrintError(Display *dpy, XErrorEvent *event, FILE *fp);
+
+/* declare an error handler that does not exit when an error
+ * event is catched.
+ */
+
+int nxagentErrorHandler(Display *dpy, XErrorEvent *event)
+{
+ if (nxagentVerbose == 1)
+ {
+ nxagentPrintError(dpy, event, stderr);
+ }
+
+ return 0;
+}
+
+/* copied from XlibInt.c */
+/* extension stuff roughly commented out */
+static int nxagentPrintError(dpy, event, fp)
+ Display *dpy;
+ XErrorEvent *event;
+ FILE *fp;
+{
+ char buffer[BUFSIZ];
+ char mesg[BUFSIZ];
+ char number[32];
+ char *mtype = "XlibMessage";
+ /*
+ register _XExtension *ext = (_XExtension *)NULL;
+ _XExtension *bext = (_XExtension *)NULL;
+ */
+ XGetErrorText(dpy, event->error_code, buffer, BUFSIZ);
+ XGetErrorDatabaseText(dpy, mtype, "XError", "X Error", mesg, BUFSIZ);
+ (void) fprintf(fp, "%s: %s\n ", mesg, buffer);
+ XGetErrorDatabaseText(dpy, mtype, "MajorCode", "Request Major code %d",
+ mesg, BUFSIZ);
+ (void) fprintf(fp, mesg, event->request_code);
+ if (event->request_code < 128) {
+ sprintf(number, "%d", event->request_code);
+ XGetErrorDatabaseText(dpy, "XRequest", number, "", buffer, BUFSIZ);
+ } else {
+ /* for (ext = dpy->ext_procs;
+ ext && (ext->codes.major_opcode != event->request_code);
+ ext = ext->next)
+ ;
+ if (ext)
+ strcpy(buffer, ext->name);
+ else
+ */
+ buffer[0] = '\0';
+ }
+ (void) fprintf(fp, " (%s)\n", buffer);
+ if (event->request_code >= 128) {
+ XGetErrorDatabaseText(dpy, mtype, "MinorCode", "Request Minor code %d",
+ mesg, BUFSIZ);
+ fputs(" ", fp);
+ (void) fprintf(fp, mesg, event->minor_code);
+ /*
+ if (ext) {
+ sprintf(mesg, "%s.%d", ext->name, event->minor_code);
+ XGetErrorDatabaseText(dpy, "XRequest", mesg, "", buffer, BUFSIZ);
+ (void) fprintf(fp, " (%s)", buffer);
+ }
+ */
+ fputs("\n", fp);
+ }
+ if (event->error_code >= 128) {
+ /* kludge, try to find the extension that caused it */
+ buffer[0] = '\0';
+ /*
+ for (ext = dpy->ext_procs; ext; ext = ext->next) {
+ if (ext->error_string)
+ (*ext->error_string)(dpy, event->error_code, &ext->codes,
+ buffer, BUFSIZ);
+ if (buffer[0]) {
+ bext = ext;
+ break;
+ }
+ if (ext->codes.first_error &&
+ ext->codes.first_error < (int)event->error_code &&
+ (!bext || ext->codes.first_error > bext->codes.first_error))
+ bext = ext;
+ }
+ if (bext)
+ sprintf(buffer, "%s.%d", bext->name,
+ event->error_code - bext->codes.first_error);
+ else
+ */
+ strcpy(buffer, "Value");
+ XGetErrorDatabaseText(dpy, mtype, buffer, "", mesg, BUFSIZ);
+ if (mesg[0]) {
+ fputs(" ", fp);
+ (void) fprintf(fp, mesg, event->resourceid);
+ fputs("\n", fp);
+ }
+ /* let extensions try to print the values */
+ /*
+ for (ext = dpy->ext_procs; ext; ext = ext->next) {
+ if (ext->error_values)
+ (*ext->error_values)(dpy, event, fp);
+ }
+ */
+ } else if ((event->error_code == BadWindow) ||
+ (event->error_code == BadPixmap) ||
+ (event->error_code == BadCursor) ||
+ (event->error_code == BadFont) ||
+ (event->error_code == BadDrawable) ||
+ (event->error_code == BadColor) ||
+ (event->error_code == BadGC) ||
+ (event->error_code == BadIDChoice) ||
+ (event->error_code == BadValue) ||
+ (event->error_code == BadAtom)) {
+ if (event->error_code == BadValue)
+ XGetErrorDatabaseText(dpy, mtype, "Value", "Value 0x%x",
+ mesg, BUFSIZ);
+ else if (event->error_code == BadAtom)
+ XGetErrorDatabaseText(dpy, mtype, "AtomID", "AtomID 0x%x",
+ mesg, BUFSIZ);
+ else
+ XGetErrorDatabaseText(dpy, mtype, "ResourceID", "ResourceID 0x%x",
+ mesg, BUFSIZ);
+ fputs(" ", fp);
+ (void) fprintf(fp, mesg, event->resourceid);
+ fputs("\n", fp);
+ }
+ XGetErrorDatabaseText(dpy, mtype, "ErrorSerial", "Error Serial #%d",
+ mesg, BUFSIZ);
+ fputs(" ", fp);
+ (void) fprintf(fp, mesg, event->serial);
+ XGetErrorDatabaseText(dpy, mtype, "CurrentSerial", "Current Serial #%d",
+ mesg, BUFSIZ);
+ fputs("\n ", fp);
+ /* (void) fprintf(fp, mesg, dpy->request); */
+ fputs("\n", fp);
+ if (event->error_code == BadImplementation) return 0;
+ return 1;
+}
+
+int nxagentExitHandler(const char *message)
+{
+ FatalError(message);
+
+ return 0;
+}
+
+void nxagentOpenClientsLogFile()
+{
+ char * clientsLogName;
+
+ if (*nxagentClientsLogName == '\0')
+ {
+ clientsLogName = nxagentGetClientsPath();
+
+ if (clientsLogName != NULL)
+ {
+ free(clientsLogName);
+ }
+ }
+
+ if (nxagentClientsLogName != NULL && *nxagentClientsLogName !='\0')
+ {
+ nxagentClientsLog = open(nxagentClientsLogName, O_RDWR | O_CREAT | O_APPEND, 0600);
+
+ if (nxagentClientsLog == -1)
+ {
+ fprintf(stderr, "Warning: Failed to open clients log. Error is %d '%s'.\n",
+ errno, strerror(errno));
+ }
+ }
+ else
+ {
+ #ifdef TEST
+ fprintf(stderr, "nxagentOpenClientsLogFile: Cannot open clients log file. The path does not exist.\n");
+ #endif
+ }
+}
+
+void nxagentCloseClientsLogFile(void)
+{
+ close(nxagentClientsLog);
+}
+
+void nxagentStartRedirectToClientsLog(void)
+{
+ nxagentOpenClientsLogFile();
+
+ if (nxagentClientsLog != -1)
+ {
+ if (nxagentStderrBackup == -1)
+ {
+ nxagentStderrBackup = dup(2);
+ }
+
+ if (nxagentStderrBackup != -1)
+ {
+ nxagentStderrDup = dup2(nxagentClientsLog, 2);
+
+ if (nxagentStderrDup == -1)
+ {
+ fprintf(stderr, "Warning: Failed to redirect stderr. Error is %d '%s'.\n",
+ errno, strerror(errno));
+ }
+ }
+ else
+ {
+ fprintf(stderr, "Warning: Failed to backup stderr. Error is %d '%s'.\n",
+ errno, strerror(errno));
+ }
+ }
+}
+
+void nxagentEndRedirectToClientsLog(void)
+{
+ if (nxagentStderrBackup != -1)
+ {
+ nxagentStderrDup = dup2(nxagentStderrBackup, 2);
+
+ if (nxagentStderrDup == -1)
+ {
+ fprintf(stderr, "Warning: Failed to restore stderr. Error is %d '%s'.\n",
+ errno, strerror(errno));
+ }
+ }
+
+ nxagentCloseClientsLogFile();
+}
+
+char *nxagentGetHomePath(void)
+{
+ char *homeEnv;
+ char *homePath;
+
+ if (*nxagentHomeDir == '\0')
+ {
+ /*
+ * Check the NX_HOME environment.
+ */
+
+ homeEnv = getenv("NX_HOME");
+
+ if (homeEnv == NULL || *homeEnv == '\0')
+ {
+ #ifdef TEST
+ fprintf(stderr, "nxagentGetHomePath: No environment for NX_HOME.\n");
+ #endif
+
+ homeEnv = getenv("HOME");
+
+ if (homeEnv == NULL || *homeEnv == '\0')
+ {
+ #ifdef PANIC
+ fprintf(stderr, "nxagentGetHomePath: PANIC! No environment for HOME.\n");
+ #endif
+
+ return NULL;
+ }
+ }
+
+ if (strlen(homeEnv) > DEFAULT_STRING_LENGTH - 1)
+ {
+ #ifdef PANIC
+ fprintf(stderr, "nxagentGetHomePath: PANIC! Invalid value for the NX "
+ "home directory '%s'.\n", homeEnv);
+ #endif
+ }
+
+ strncpy(nxagentHomeDir, homeEnv, DEFAULT_STRING_LENGTH - 1);
+
+ #ifdef TEST
+ fprintf(stderr, "nxagentGetHomePath: Assuming NX user's home directory '%s'.\n", nxagentHomeDir);
+ #endif
+ }
+
+ homePath = (char*) malloc(strlen(nxagentHomeDir) + 1);
+
+ if (homePath == NULL)
+ {
+ #ifdef PANIC
+ fprintf(stderr, "nxagentGetHomePath: PANIC! Can't allocate memory for the home path.\n");
+ #endif
+
+ return NULL;
+ }
+
+ strcpy(homePath, nxagentHomeDir);
+
+ return homePath;
+}
+
+char *nxagentGetRootPath(void)
+{
+ char *rootEnv;
+ char *homeEnv;
+ char *rootPath;
+
+ struct stat dirStat;
+
+ if (*nxagentRootDir == '\0')
+ {
+ /*
+ * Check the NX_ROOT environment.
+ */
+
+ rootEnv = getenv("NX_ROOT");
+
+ if (rootEnv == NULL || *rootEnv == '\0')
+ {
+ #ifdef TEST
+ fprintf(stderr, "nxagentGetRootPath: WARNING! No environment for NX_ROOT.\n");
+ #endif
+
+ /*
+ * We will determine the root NX directory
+ * based on the NX_HOME or HOME directory
+ * settings.
+ */
+
+ homeEnv = nxagentGetHomePath();
+
+ if (homeEnv == NULL)
+ {
+
+ #ifdef PANIC
+ #endif
+
+ return NULL;
+ }
+
+ if (strlen(homeEnv) > DEFAULT_STRING_LENGTH -
+ strlen("/.nx") - 1)
+ {
+ #ifdef PANIC
+ fprintf(stderr, "nxagentGetRootPath: PANIC! Invalid value for the NX "
+ "home directory '%s'.\n", homeEnv);
+ #endif
+
+ free(homeEnv);
+
+ return NULL;
+ }
+
+ #ifdef TEST
+ fprintf(stderr, "nxagentGetRootPath: Assuming NX root directory in '%s'.\n", homeEnv);
+ #endif
+
+ strcpy(nxagentRootDir, homeEnv);
+ strcat(nxagentRootDir, "/.nx");
+
+ free(homeEnv);
+
+ /*
+ * Create the NX root directory.
+ */
+
+ if ((stat(nxagentRootDir, &dirStat) == -1) && (errno == ENOENT))
+ {
+ if (mkdir(nxagentRootDir, 0777) < 0 && (errno != EEXIST))
+ {
+ #ifdef PANIC
+ fprintf(stderr, "nxagentGetRootPath: PANIC! Can't create directory '%s'. Error is %d '%s'.\n",
+ nxagentRootDir, errno, strerror(errno));
+ #endif
+
+ return NULL;
+ }
+ }
+ }
+ else
+ {
+ if (strlen(rootEnv) > DEFAULT_STRING_LENGTH - 1)
+ {
+ #ifdef PANIC
+ fprintf(stderr, "nxagentGetRootPath: PANIC! Invalid value for the NX root directory '%s'.\n",
+ rootEnv);
+ #endif
+
+ return NULL;
+ }
+
+ strcpy(nxagentRootDir, rootEnv);
+ }
+
+ #ifdef TEST
+ fprintf(stderr, "nxagentGetRootPath: Assuming NX root directory '%s'.\n",
+ nxagentRootDir);
+ #endif
+
+ }
+
+ rootPath = malloc(strlen(nxagentRootDir) + 1);
+
+ if (rootPath == NULL)
+ {
+ #ifdef PANIC
+ fprintf(stderr, "nxagentGetRootPath: Can't allocate memory for the root path.\n");
+ #endif
+
+ return NULL;
+ }
+
+ strcpy(rootPath, nxagentRootDir);
+
+ return rootPath;
+}
+
+char *nxagentGetSessionPath()
+{
+
+ char *rootPath;
+ char *sessionPath;
+
+ struct stat dirStat;
+
+ if (*nxagentSessionDir == '\0')
+ {
+ /*
+ * If nxagentSessionId does not exist we
+ * assume that the sessionPath cannot be
+ * realized and do not use the clients
+ * log file.
+ */
+
+ if (*nxagentSessionId == '\0')
+ {
+ #ifdef TEST
+ fprintf(stderr, "nxagentGetSessionPath: Session id does not exist. Assuming session path NULL.\n");
+ #endif
+
+ return NULL;
+ }
+
+ rootPath = nxagentGetRootPath();
+
+ if (rootPath == NULL)
+ {
+ return NULL;
+ }
+
+ strcpy(nxagentSessionDir, rootPath);
+
+ free(rootPath);
+
+ if (strlen(nxagentSessionDir) + strlen("/C-") + strlen(nxagentSessionId) > DEFAULT_STRING_LENGTH - 1)
+ {
+ #ifdef PANIC
+ fprintf(stderr, "nxagentGetSessionPath: PANIC!: Invalid value for the NX session directory '%s'.\n",
+ nxagentSessionDir);
+ #endif
+
+ return NULL;
+ }
+
+ strcat(nxagentSessionDir, "/C-");
+
+ strcat(nxagentSessionDir, nxagentSessionId);
+
+ if ((stat(nxagentSessionDir, &dirStat) == -1) && (errno == ENOENT))
+ {
+ if (mkdir(nxagentSessionDir, 0777) < 0 && (errno != EEXIST))
+ {
+ #ifdef PANIC
+ fprintf(stderr, "nxagentGetSessionPath: PANIC! Can't create directory '%s'. Error is %d '%s'.\n",
+ nxagentSessionDir, errno, strerror(errno));
+ #endif
+
+ return NULL;
+ }
+ }
+
+ #ifdef TEST
+ fprintf(stderr, "nxagentGetSessionPath: NX session is '%s'.\n",
+ nxagentSessionDir);
+ #endif
+
+ }
+
+ sessionPath = malloc(strlen(nxagentSessionDir) + 1);
+
+ if (sessionPath == NULL)
+ {
+ #ifdef PANIC
+ fprintf(stderr, "nxagentGetSessionPath:: PANIC! Can't allocate memory for the session path.\n");
+ #endif
+
+ return NULL;
+ }
+
+
+ strcpy(sessionPath, nxagentSessionDir);
+
+ return sessionPath;
+}
+
+char *nxagentGetClientsPath()
+{
+ char *sessionPath;
+ char *clientsPath;
+
+ if (*nxagentClientsLogName == '\0')
+ {
+ sessionPath = nxagentGetSessionPath();
+
+ if (sessionPath == NULL)
+ {
+ return NULL;
+ }
+
+ if (strlen(sessionPath) + strlen("/clients") > DEFAULT_STRING_LENGTH - 1)
+ {
+ #ifdef PANIC
+ fprintf(stderr, "nxagentGetClientsPath: PANIC! Invalid value for the NX clients Log File Path '%s'.\n",
+ nxagentClientsLogName);
+ #endif
+
+ free(sessionPath);
+
+ return NULL;
+ }
+
+ strcpy(nxagentClientsLogName, sessionPath);
+
+ strcat(nxagentClientsLogName, "/clients");
+
+ free(sessionPath);
+ }
+
+ clientsPath = malloc(strlen(nxagentClientsLogName) + 1);
+
+ if (clientsPath == NULL)
+ {
+ #ifdef PANIC
+ fprintf(stderr, "nxagentGetClientsPath: PANIC! Can't allocate memory for the clients Log File Path path.\n");
+ #endif
+
+ return NULL;
+ }
+
+ strcpy(clientsPath, nxagentClientsLogName);
+
+ return clientsPath;
+}
+