gtk-server.c

gtk_server的源代码

    unsigned int button;
    #else
    void *object;
    int button;
    #endif
    long state;
    int p1;
    int p2;
    int p3;
    int p4;
    int p5;
    int p6;
    int p7;
    char *text;
    char* t1;
    char* t2;
    char* t3;
    char* t4;
    char* t5;
    char* t6;
    char* t7;
    int mousex;
    int mousey;
    int key;
    int scroll;
};

/* Define global instance of current callback */
struct callback Current_Object;

/* Structure to define the behaviour of GTK-server */
struct behaviour {
    int count_fork;		/* Keeps track of forking when in TCP mode */
    int c_escaped;		/* Define if returned strings will have escaped special characters 0=off, 1=on, 2=string */
    unsigned char escapes[16];	/* Keep chars to escape, maximum 16 */
    char *fifo;			/* Keep name of FIFO file (Linux) */
    char *tcp;			/* Keep name of TCP data when in TCP mode */
    char *udp;			/* Keep name of UDP data when in UDP mode */
    char *LogDir;		/* Location of the logfile */
    char *pre;			/* Additional text to put before the returnstring */
    char *post;			/* Additional text to put after the returnstring */
    char *macro;		/* Only used when GTK-server needs to start with a macro */
    char *init;			/* Used when GTk-server needs to send an INIT string as TCP client */
    char *certificate;		/* Location of the SSL certificate to identify ourselves when connecting */
    char *ca;			/* Location of the trusted CA (Certificate Authority) */
    char *password;		/* Password to decrypt SSL certificate */
    char *handle;		/* Keep handle of current request */
    int ipc;			/* The signal number to use when in IPC mode */
    int exit_sig;		/* Keep exit signal to send to PPID */
    int ppid;			/* Keep PID of parent */
    int behave;			/* Binary flag
				    -list of configured calls	000000001
				    -do not create FIFO file	000000010
				    -do not spawn to backgrnd	000000100
				    -send signal on exit	000001000
				    -run a macro first		000010000
				    -send INIT string		000100000
				    -use SSL encryption	wo cert	001000000
				    -use SSL encryption	& cert	010000000
				    -use check on handle	100000000*/
    int mode;			/* Are we running in STDIN, FIFO, IPC, TCP, UDP mode? */
};

/* Global instance to hold the behaviour of GTK-server */
struct behaviour gtkserver;

/* Define list to parse a line */
typedef struct parsed_data {
    char *arg;
    struct parsed_data *next;
} PARSED;

/* Struct for message queues */
struct msg_buf {
    long mtype;
    char mtext[MAX_LEN];    /* MSGMNB is the max size, MAX_LEN must be a lower value */
};

typedef struct wid_sig {
    #if GTK1 || GTK2
    GtkWidget* widget;
    #elif GTK_SERVER_XF
    FL_OBJECT *widget;
    #endif
    char* data;
    struct wid_sig *next;
} ASSOC;

ASSOC *List_Sigs = NULL;
ASSOC *Start_List_Sigs = NULL;

/* These variable names are addresses by themselves and used by GTK to store returnvalues */
long long_address[MAX_ARGS];
int int_address[MAX_ARGS];
float float_address[MAX_ARGS];
double double_address[MAX_ARGS];
char *str_address[MAX_ARGS];
#if GTK_SERVER_GTK1x || GTK_SERVER_GTK2x
GtkObject *obj_address[MAX_ARGS];
#elif GTK_SERVER_XF
FL_OBJECT *obj_address[MAX_ARGS];
#else
void *obj_address[MAX_ARGS];
#endif

/* Declare callback routines */
#if GTK_SERVER_GTK1x || GTK_SERVER_GTK2x
void gtk_server_callback_extra2(GtkWidget *widget, gpointer *data1);
void gtk_server_callback_extra3(GtkWidget *widget, gpointer *data1, gpointer *data2);
void gtk_server_callback_extra4(GtkWidget *widget, gpointer *data1, gpointer *data2, gpointer *data3);
void gtk_server_callback_extra5(GtkWidget *widget, gpointer *data1, gpointer *data2, gpointer *data3, gpointer *data4);
void gtk_server_callback_extra6(GtkWidget *widget, gpointer *data1, gpointer *data2, gpointer *data3, gpointer *data4, gpointer *data5);
void gtk_server_callback_extra7(GtkWidget *widget, gpointer *data1, gpointer *data2, gpointer *data3, gpointer *data4, gpointer *data5, gpointer *data6);
void gtk_server_callback_extra8(GtkWidget *widget, gpointer *data1, gpointer *data2, gpointer *data3, gpointer *data4, gpointer *data5, gpointer *data6, gpointer *data7);
gboolean gtk_server_callback_extra2_bool(GtkWidget *widget, gpointer *data1);
gboolean gtk_server_callback_extra3_bool(GtkWidget *widget, gpointer *data1, gpointer *data2);
gboolean gtk_server_callback_extra4_bool(GtkWidget *widget, gpointer *data1, gpointer *data2, gpointer *data3);
gboolean gtk_server_callback_extra5_bool(GtkWidget *widget, gpointer *data1, gpointer *data2, gpointer *data3, gpointer *data4);
gboolean gtk_server_callback_extra6_bool(GtkWidget *widget, gpointer *data1, gpointer *data2, gpointer *data3, gpointer *data4, gpointer *data5);
gboolean gtk_server_callback_extra7_bool(GtkWidget *widget, gpointer *data1, gpointer *data2, gpointer *data3, gpointer *data4, gpointer *data5, gpointer *data6);
gboolean gtk_server_callback_extra8_bool(GtkWidget *widget, gpointer *data1, gpointer *data2, gpointer *data3, gpointer *data4, gpointer *data5, gpointer *data6, gpointer *data7);
#endif

/* Collect all callback functions for gtk_server_connect */
#ifdef GTK_SERVER_GTK1x
GtkCallback gtk_server_callbacks[] = {
    GTK_SIGNAL_FUNC(gtk_server_callback_extra2),
    GTK_SIGNAL_FUNC(gtk_server_callback_extra3),
    GTK_SIGNAL_FUNC(gtk_server_callback_extra4),
    GTK_SIGNAL_FUNC(gtk_server_callback_extra5),
    GTK_SIGNAL_FUNC(gtk_server_callback_extra6),
    GTK_SIGNAL_FUNC(gtk_server_callback_extra7),
    GTK_SIGNAL_FUNC(gtk_server_callback_extra8),
    GTK_SIGNAL_FUNC(gtk_server_callback_extra2_bool),
    GTK_SIGNAL_FUNC(gtk_server_callback_extra3_bool),
    GTK_SIGNAL_FUNC(gtk_server_callback_extra4_bool),
    GTK_SIGNAL_FUNC(gtk_server_callback_extra5_bool),
    GTK_SIGNAL_FUNC(gtk_server_callback_extra6_bool),
    GTK_SIGNAL_FUNC(gtk_server_callback_extra7_bool),
    GTK_SIGNAL_FUNC(gtk_server_callback_extra8_bool)
};
#elif GTK_SERVER_GTK2x
GCallback gtk_server_callbacks[] = {
    G_CALLBACK(gtk_server_callback_extra2),
    G_CALLBACK(gtk_server_callback_extra3),
    G_CALLBACK(gtk_server_callback_extra4),
    G_CALLBACK(gtk_server_callback_extra5),
    G_CALLBACK(gtk_server_callback_extra6),
    G_CALLBACK(gtk_server_callback_extra7),
    G_CALLBACK(gtk_server_callback_extra8),
    G_CALLBACK(gtk_server_callback_extra2_bool),
    G_CALLBACK(gtk_server_callback_extra3_bool),
    G_CALLBACK(gtk_server_callback_extra4_bool),
    G_CALLBACK(gtk_server_callback_extra5_bool),
    G_CALLBACK(gtk_server_callback_extra6_bool),
    G_CALLBACK(gtk_server_callback_extra7_bool),
    G_CALLBACK(gtk_server_callback_extra8_bool)
};
#endif

/* Define logfile facility */
FILE *logfile;

/* Translation Tables as described in RFC1113 - Needed for Base64 decoding */
static const char cd64[]="|$$$}rstuvwxyz{$$$$$$$>?@ABCDEFGHIJKLMNOPQRSTUVW$$$$$$XYZ[\\]^_`abcdefghijklmnopq";

char *Call_Realize (char*, void*);

#ifdef GTK_SERVER_LIBRARY

/* Define the returnstring */
char *retstr;
/* Define static buffer in which to return total string */
char *send_buffer=NULL;
/* Define list for CONFIGURATION settings */
CONFIG *Gtk_Api_Config = NULL;
/* Define list for macro definitions */
MACRO *Macro_Defs;
MACRO *Macro_Last;
MACRO *Start_Macro_Defs;
BODY *Body_Text;
BODY *Body_Last;
/* Define list for enum definitions */
ENUM *Enum_Defs;
ALIAS *Alias_Defs;

char *filename;

#endif

/* Define the librarynames to open */
char *libs[MAX_LIBS];
#if GTK_SERVER_FFI || GTK_SERVER_FFCALL
    #ifdef GTK_SERVER_UNIX
    void *handle[MAX_LIBS];
    #elif GTK_SERVER_WIN32
    HINSTANCE handle[MAX_LIBS];
    #endif
    void *cinv_ctx;
#elif GTK_SERVER_CINV
CInvContext *cinv_ctx;
CInvLibrary *handle[MAX_LIBS];
#elif GTK_SERVER_DYNCALL
void *handle[MAX_LIBS];
void *cinv_ctx;
#endif

/*************************************************************************************************/

/* This function was rewritten by Jim Bailey */

char *Trim_String(char *data)
{
int last_idx;
/* Get rid of whitespaces at the beginning of the string */
while (*data == ' '|| *data == '\t' || *data == '\n' || *data == '\r') data++;
/* Check there is anything left to chop off at the end */
last_idx = strlen( data ) - 1;
if ( last_idx < 0 ) return data;
/* Find the last non-whitespace at the end of the string */
while ( data[last_idx] == ' ' || data[last_idx] == '\t' || data[last_idx] == '\n' || *data == '\r') last_idx--;
/* Actually chop off the whitespaces at the end of the string */
data[last_idx+1] = '\0';
/* Return stripped string */
return data;
}

/*************************************************************************************************/

/* Check if a charpointer really contains a long number */

int is_value (char *var) 
{
int i;

if (var != NULL){
    for (i = 0; i < strlen(var); i++){
	if ((*(var + i) < 48 || *(var + i) > 57) && *(var + i) != 32 && *(var + i) != 9 && *(var + i) != 45 && *(var + i) != 43) return 0;
    }
    return 1;
}
/* If NULL, value is not a number */
return 0;
}

/*************************************************************************************************/

#ifdef GTK_SERVER_NOSNPRINTF
void snprintf(char *result, int no, char *fmt, ...)
{
va_list args;

va_start(args, fmt);

vsprintf(result, fmt, args); 

va_end(args);
}
#endif

/*************************************************************************************************/

void mystrcat(char** pointer, char *string)
{
char *new;

if (strlen(*pointer) + strlen(string) > MAX_LEN){
    new = malloc(strlen(*pointer) + strlen(string) + MAX_LEN);
    strncpy(new, *pointer, strlen(*pointer));
    strncat(new, string, strlen(string));
    free(*pointer);
    *pointer = new;
}
else strncat(*pointer, string, strlen(string));

}

/**************************************************************************************************/
/* I wanted to use 'fmemopen' but this is not portable. Therefore this 'fmemgets' function to read
    a string as if it were a file. */

char *fmemgets(char *s, int size, char *stream)
{
char *nl;

/* Result buffer must be empty */
memset(s, '\0', size);

nl = stream;

/* Check if we are at the end of the string already */
if (nl == NULL || *nl == '\0') return NULL;

/* No, search for next \n or \0 */
while(*nl != '\0' && *nl != '\n') nl++;

if (nl - stream > size){
    strncpy(s, stream, size);
    stream += size;
}
else {
    strncpy(s, stream, nl - stream);
    stream = nl;
}

/* End of string? Return NULL */
if (*stream == '\0') return NULL;

/* Else return rest of the stream */
return ++stream;
}

/*************************************************************************************************/
/* When the GTK-server exits, remove the created pipe, but first send an 'OK'.	Oct 10, 2006	*/
/* Use print to stderr here, since we are already in the 'atexit' EXIT function. */

#ifdef GTK_SERVER_UNIX
void remove_pipe(void)
{
int sockfd;

/* Open in WRITE mode */
if (gtkserver.behave & 8)
    sockfd = open(gtkserver.fifo, O_RDWR|O_NONBLOCK);
else
    sockfd = open(gtkserver.fifo, O_WRONLY);

/* Return OK */
if (sockfd >= 0) {
    write (sockfd, "ok\n", strlen("ok\n"));
    /* Close socket again */
    close(sockfd);