Jabber WindowGram Client (JWGC)

00001 #include <sysdep.h>
00002 
00003 /*
00004  *      Parts of this this are from MIT's Zephyr system, and the following
00005  *      applies to those parts:
00006  *
00007  *      Copyright (c) 1989 by the Massachusetts Institute of Technology.
00008  *      For copying and distribution information, see the file
00009  *      "mit-copyright.h".
00010  */
00011 
00012 /* $Id: JVariables.c,v 1.21 2004/04/13 18:39:01 jadestorm Exp $ */
00013 
00014 #include "libjwgc.h"
00015 
00016 int jVars_fixed[jNumVars];
00017 int jVars_types[jNumVars];
00018 char *jVars_strings[jNumVars];
00019 void *jVars_contents[jNumVars];
00020 static void (*jVars_change_handler[jNumVars]) ();
00021 static int (*jVars_check_handler[jNumVars]) ();
00022 static int (*jVars_show_handler[jNumVars]) ();
00023 static void (*jVars_defaults_handler) ();
00024 
00025 void jVars_read_conf(char *file, int locksettings);
00026 void jVars_read_defaults();
00027 void jVars_set_error(char *errorstr);
00028 char *jVars_get_error();
00029 
00030 #define max(a,b) ((a > b) ? (a) : (b))
00031 char *varfiledefaults;
00032 char *varfilefixed;
00033 char *varfilepersonal;
00034 char *varerrorstr;
00035 
00036 static int 
00037 varline(bfr, var)
00038         char *bfr;
00039         char *var;
00040 {
00041         register char *cp;
00042 
00043 
00044         if (!bfr[0] || bfr[0] == '#')
00045                 return (0);
00046 
00047         cp = bfr;
00048         while (*cp && !isspace(*cp) && (*cp != '='))
00049                 cp++;
00050 
00051         if (strncasecmp(bfr, var, max(strlen(var), cp - bfr)))
00052                 return (0);
00053 
00054         cp = (char *) strchr(bfr, '=');
00055         if (!cp)
00056                 return (0);
00057         cp++;
00058         while (*cp && isspace(*cp))
00059                 cp++;
00060 
00061         return (cp - bfr);
00062 }
00063 
00064 int 
00065 jVars_set_personal_var(var, value)
00066         char *var;
00067         char *value;
00068 {
00069         int written;
00070         FILE *fpin, *fpout;
00071         char *varfilebackup, varbfr[512];
00072 
00073         written = 0;
00074 
00075         if (!varfilepersonal)
00076                 return 0;
00077 
00078         varfilebackup = (char *)malloc(sizeof(char) *
00079                         (strlen(varfilepersonal) + 7 + 1));
00080         strcpy(varfilebackup, varfilepersonal);
00081         strcat(varfilebackup, ".backup");
00082 
00083         if (!(fpout = fopen(varfilebackup, "w")))
00084                 return 0;
00085 
00086         if ((fpin = fopen(varfilepersonal, "r")) != NULL) {
00087                 while (fgets(varbfr, sizeof varbfr, fpin) != (char *) 0) {
00088                         varbfr[511] = '\0';
00089 
00090                         if (varline(varbfr, var)) {
00091                                 fprintf(fpout, "%s = %s\n", var, value);
00092                                 written = 1;
00093                         }
00094                         else
00095                                 fprintf(fpout, "%s\n", varbfr);
00096                 }
00097                 fclose(fpin);
00098         }
00099 
00100         if (!written)
00101                 fprintf(fpout, "%s = %s\n", var, value);
00102 
00103         if (fclose(fpout) == EOF)
00104                 return 0;
00105 
00106         if (rename(varfilebackup, varfilepersonal))
00107                 return 0;
00108 
00109         return 1;
00110 }
00111 
00112 int 
00113 jVars_unset_personal_var(var)
00114         char *var;
00115 {
00116         FILE *fpin, *fpout;
00117         char *varfilebackup, varbfr[512];
00118 
00119         varfilebackup = (char *)malloc(sizeof(char) *
00120                         (strlen(varfilepersonal) + 7 + 1));
00121         strcpy(varfilebackup, varfilepersonal);
00122         strcat(varfilebackup, ".backup");
00123 
00124         if (!(fpout = fopen(varfilebackup, "w")))
00125                 return 0;
00126 
00127         if ((fpin = fopen(varfilepersonal, "r")) != NULL) {
00128                 while (fgets(varbfr, sizeof varbfr, fpin) != (char *) 0) {
00129                         varbfr[511] = '\0';
00130 
00131                         if (!varline(varbfr, var))
00132                                 fprintf(fpout, "%s\n", varbfr);
00133                 }
00134                 fclose(fpin);
00135         }
00136 
00137         if (fclose(fpout) == EOF)
00138                 return 0;
00139 
00140         if (rename(varfilebackup, varfilepersonal))
00141                 return 0;
00142 
00143         return 1;
00144 }
00145 
00146 int 
00147 jVars_init()
00148 {
00149         jVar i;
00150         struct passwd *pwd;
00151         char *envptr, *homedir;
00152 
00153         dprintf(dVars, "Initializing variable manager...\n");
00154 
00155         varfiledefaults = NULL;
00156         varfilefixed = NULL;
00157         varfilepersonal = NULL;
00158         varerrorstr = NULL;
00159 
00160         for (i = 0; i < jNumVars; i++) {
00161                 jVars_fixed[i] = 0;
00162                 jVars_contents[i] = NULL;
00163                 jVars_check_handler[i] = NULL;
00164                 jVars_change_handler[i] = NULL;
00165                 jVars_show_handler[i] = NULL;
00166         }
00167 
00168         if ((envptr = (char *) getenv("HOME"))) {
00169                 homedir = strdup(envptr);
00170         }
00171         else {
00172                 if (!(pwd = getpwuid((int) getuid()))) {
00173                         jVars_set_error("Can't find your entry in /etc/passwd.");
00174                         return 0;
00175                 }
00176                 homedir = strdup(pwd->pw_dir);
00177         }
00178 
00179         varfilepersonal = (char *)malloc(sizeof(char) *
00180                         (strlen(homedir) + 1 + strlen(USRVARS) + 1));
00181         strcpy(varfilepersonal, homedir);
00182         strcat(varfilepersonal, "/");
00183         strcat(varfilepersonal, USRVARS);
00184 
00185         varfilefixed = (char *)malloc(strlen(DATADIR) + strlen(FIXEDVARS) + 2);
00186         sprintf(varfilefixed, "%s/%s", DATADIR, FIXEDVARS);
00187 
00188         varfiledefaults = (char *)malloc(strlen(DATADIR) + strlen(DEFVARS) + 2);
00189         sprintf(varfiledefaults, "%s/%s", DATADIR, DEFVARS);
00190 
00191         jVars_strings[jVarUsername] = "username";
00192         jVars_types[jVarUsername] = jTypeString;
00193 
00194         jVars_strings[jVarPassword] = "password";
00195         jVars_types[jVarPassword] = jTypeString;
00196 
00197         jVars_strings[jVarServer] = "server";
00198         jVars_types[jVarServer] = jTypeString;
00199 
00200         jVars_strings[jVarResource] = "resource";
00201         jVars_types[jVarResource] = jTypeString;
00202 
00203         jVars_strings[jVarPort] = "port";
00204         jVars_types[jVarPort] = jTypeNumber;
00205 
00206         jVars_strings[jVarPriority] = "priority";
00207         jVars_types[jVarPriority] = jTypeNumber;
00208 
00209 #ifdef USE_SSL
00210         jVars_strings[jVarUseSSL] = "usessl";
00211         jVars_types[jVarUseSSL] = jTypeBool;
00212 #endif /* USE_SSL */
00213 
00214         jVars_strings[jVarInitProgs] = "initprogs";
00215         jVars_types[jVarInitProgs] = jTypeString;
00216 
00217         jVars_strings[jVarJID] = "jid";
00218         jVars_types[jVarJID] = jTypeString;
00219 
00220         jVars_strings[jVarPresence] = "presence";
00221         jVars_types[jVarPresence] = jTypeString;
00222 
00223 #ifdef USE_GPGME
00224         jVars_strings[jVarUseGPG] = "usegpg";
00225         jVars_types[jVarUseGPG] = jTypeBool;
00226 
00227         jVars_strings[jVarGPGPass] = "gpgpass";
00228         jVars_types[jVarGPGPass] = jTypeString;
00229 
00230         jVars_strings[jVarGPGKeyID] = "gpgkeyid";
00231         jVars_types[jVarGPGKeyID] = jTypeString;
00232 #endif /* USE_GPGME */
00233 
00234         if (*jVars_defaults_handler) {
00235                 jVars_defaults_handler();
00236         }
00237         jVars_read_defaults();
00238 
00239         return 1;
00240 }
00241 
00242 void
00243 jVars_set_error(errorstr)
00244         char *errorstr;
00245 {
00246         if (varerrorstr) { free(varerrorstr); }
00247         varerrorstr = strdup(errorstr);
00248 }
00249 
00250 char *
00251 jVars_get_error()
00252 {
00253         if (varerrorstr) {
00254                 return varerrorstr;
00255         }
00256         else {
00257                 return NULL;
00258         }
00259 }
00260 
00261 void
00262 jVars_set_change_handler(jvar, handler)
00263         jVar jvar;
00264         void (*handler) ();
00265 {
00266         jVars_change_handler[jvar] = handler;
00267 }
00268 
00269 void
00270 jVars_set_check_handler(jvar, handler)
00271         jVar jvar;
00272         int (*handler) ();
00273 {
00274         jVars_check_handler[jvar] = handler;
00275 }
00276 
00277 void
00278 jVars_set_show_handler(jvar, handler)
00279         jVar jvar;
00280         int (*handler) ();
00281 {
00282         jVars_show_handler[jvar] = handler;
00283 }
00284 
00285 void
00286 jVars_set_defaults_handler(handler)
00287         void (*handler) ();
00288 {
00289         jVars_defaults_handler = handler;
00290 }
00291 
00292 void *
00293 jVars_get(name)
00294         jVar name;
00295 {
00296         if (name >= jNumVars || name < 0) {
00297                 return NULL;
00298         }
00299 
00300         if (jVars_contents[name]) {
00301                 return jVars_contents[name];
00302         }
00303         else {
00304                 return NULL;
00305         }
00306 }
00307 
00308 char *
00309 jVars_show(name)
00310         jVar name;
00311 {
00312         if (name >= jNumVars || name < 0) {
00313                 jVars_set_error("Variable unknown.");
00314                 return NULL;
00315         }
00316 
00317         if (*jVars_show_handler[name]) {
00318                 if (!(jVars_show_handler[name] ())) {
00319                         /* handler is expected to set error */
00320                         return NULL;
00321                 }
00322         }
00323 
00324         if (jVars_contents[name]) {
00325                 return jVars_contents[name];
00326         }
00327         else {
00328                 return (char *)"<not set>";
00329         }
00330 }
00331 
00332 int
00333 jVars_set(name, setting)
00334         jVar name;
00335         void *setting;
00336 {
00337         void *oldsetting;
00338 
00339         if (name < 0 || name >= jNumVars) {
00340                 jVars_set_error("Variable does not exist.");
00341                 return 0;
00342         }
00343 
00344         if (!setting) {
00345                 jVars_set_error("No setting specified.");
00346                 return 0;
00347         }
00348 
00349         if (*jVars_check_handler[name]) {
00350                 if (!(jVars_check_handler[name] (setting))) {
00351                         /* handler is expected to set error */
00352                         return 0;
00353                 }
00354         }
00355 
00356         if (jVars_fixed[name]) {
00357                 jVars_set_error("The variable you've selected can not be changed.");
00358                 return 0;
00359         }
00360         else {
00361                 oldsetting = jVars_contents[name];
00362                 if (jVars_types[name] == jTypeString) {
00363                         jVars_contents[name] = strdup(setting);
00364                 }
00365                 else if (jVars_types[name] == jTypeNumber) {
00366                         int *intset;
00367                         intset = (int *)malloc(sizeof(int));
00368                         *intset = atoi(setting);
00369                         jVars_contents[name] = intset;
00370                 }
00371                 else if (jVars_types[name] == jTypeBool) {
00372                         int *intset;
00373                         intset = (int *)malloc(sizeof(int));
00374                         *intset = 0;
00375                         if (!strcmp(setting, "on")
00376                                         || !strcmp(setting, "enable")
00377                                         || !strcmp(setting, "enabled")
00378                                         || !strcmp(setting, "true")
00379                                         || !strcmp(setting, "1")) {
00380                                 *intset = 1;
00381                         }
00382                         jVars_contents[name] = intset;
00383                 }
00384 
00385                 if (*jVars_change_handler[name]) {
00386                         jVars_change_handler[name] (oldsetting, jVars_contents[name]);
00387                 }
00388 
00389                 if (oldsetting != NULL) {
00390                         free(oldsetting);
00391                 }
00392         }
00393 
00394         return 1;
00395 }
00396 
00397 char *
00398 jVars_itos(jvar)
00399         jVar jvar;
00400 {
00401         return jVars_strings[jvar];
00402 }
00403 
00404 jVar 
00405 jVars_stoi(jvar)
00406         char *jvar;
00407 {
00408         jVar i;
00409 
00410         for (i = 0; i < jNumVars; i++) {
00411                 if (!strcmp(jvar, jVars_strings[i])) {
00412                         return i;
00413                 }
00414         }
00415 
00416         return -1;
00417 }
00418 
00419 void
00420 jVars_read_conf(file, locksettings)
00421         char *file;
00422         int locksettings;
00423 {
00424         FILE *fp;
00425         char *cp, *nameptr, *valptr;
00426         char varbfr[512];
00427         jVar curvar;
00428 
00429         dprintf(dVars, "Reading configuration file: %s\n", file);
00430         fp = fopen(file, "r");
00431         if (fp) {
00432                 dprintf(dVars, "Successfully opened.\n");
00433                 while (fgets(varbfr, sizeof(varbfr), fp) != (char *) 0) {
00434                         varbfr[511] = '\0';
00435                         cp = varbfr;
00436 
00437                         while (*cp && isspace(*cp))
00438                                 cp++;
00439 
00440                         if (!*cp || *cp == '=' || *cp == '#')
00441                                 continue;
00442 
00443                         nameptr = cp;
00444                         while (*cp && !isspace(*cp) && (*cp != '='))
00445                                 cp++;
00446 
00447                         *cp = '\0';
00448                         dprintf(dVars, "Found variable %s.\n", nameptr);
00449                         curvar = jVars_stoi(nameptr);
00450                         if (curvar < 0)
00451                                 continue;
00452                         cp++;
00453                         
00454                         while (*cp && (isspace(*cp) || *cp == '='))
00455                                 cp++;
00456 
00457                         if (!*cp)
00458                                 continue;
00459 
00460                         valptr = cp;
00461 
00462                         while (*cp && (*cp != '\n'))
00463                                 cp++;
00464 
00465                         if (!*cp)
00466                                 continue;
00467 
00468                         if (*cp == '\n')
00469                                 *cp = '\0';
00470 
00471                         if (valptr) {
00472                                 jVars_set(curvar, valptr);
00473                                 if (locksettings) {
00474                                         jVars_fixed[curvar] = 1;
00475                                 }
00476                         }
00477                 }
00478                 fclose(fp);
00479         }
00480 }
00481 
00482 void
00483 jVars_read_defaults()
00484 {
00485         dprintf(dVars, "Reading defaults\n");
00486         jVars_read_conf(varfilefixed, 1);
00487         jVars_read_conf(varfiledefaults, 0);
00488         if (varfilepersonal) {
00489                 jVars_read_conf(varfilepersonal, 0);
00490         }
00491 }