src/install+setup/install/upgrade-v130-v140.c

   1 /*
   2  * This file is part of the IPCop Firewall.
   3  *
   4  * IPCop is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * IPCop is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with IPCop; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17  *
  18  * Copyright 2002: Mark Wormgoor <mark@wormgoor.com>
  19  *
  20  * $Id: upgrade-v130-v140.c,v 1.12.2.35 2004/11/11 09:40:03 alanh Exp $
  21  *
  22  */
  23
  24 #include "install.h"
  25
  26 extern char **ctr;
  27
  28 int _handledomainname(void)
  29 {
  30         char domainname[STRING_SIZE] = "localdomain";
  31         struct keyvalue *kv = initkeyvalues();
  32         char *values[] = { domainname, NULL };  /* pointers for the values. */
  33         struct newtWinEntry entries[] =
  34                 { { "", &values[0], 0,}, { NULL, NULL, 0 } };
  35         int rc;
  36         int result;
  37
  38         if (!(readkeyvalues(kv, "/harddisk" CONFIG_ROOT "/main/settings")))
  39         {
  40                 freekeyvalues(kv);
  41                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
  42                 return 0;
  43         }
  44
  45         findkey(kv, "DOMAINNAME", domainname);
  46
  47         /* already have a domainname */
  48         if (strlen(domainname))
  49                 return 0;
  50
  51         for (;;)
  52         {
  53                 rc = newtWinEntries(ctr[TR_DOMAINNAME], ctr[TR_ENTER_DOMAINNAME],
  54                         50, 5, 5, 40, entries, ctr[TR_OK], ctr[TR_CANCEL], NULL);
  55
  56                 if (rc == 1)
  57                 {
  58                         strcpy(domainname, values[0]);
  59                         if (strchr(domainname, ' '))
  60                                 errorbox(ctr[TR_DOMAINNAME_CANNOT_CONTAIN_SPACES]);
  61                         else
  62                         {
  63                                 replacekeyvalue(kv, "DOMAINNAME", domainname);
  64                                 writekeyvalues(kv, "/harddisk" CONFIG_ROOT "/main/settings");
  65                                 result = 1;
  66                                 break;
  67                         }
  68                 }
  69                 else
  70                 {
  71                         result = 0;
  72                         break;
  73                 }
  74         }
  75         free(values[0]);
  76         freekeyvalues(kv);
  77
  78         return result;
  79 }
  80
  81 int _add_logwatch_user() {
  82         mysystem("/bin/chroot /harddisk /usr/sbin/userdel logwatch");
  83         mysystem("/bin/chroot /harddisk /usr/sbin/groupdel logwatch");
  84         mysystem("/bin/chroot /harddisk /usr/sbin/groupadd -g 102 logwatch");
  85         mysystem("/bin/chroot /harddisk /usr/sbin/useradd  -u 102 -g logwatch -d /var/log/logwatch -s /bin/false logwatch");
  86
  87         return 0;
  88 }
  89
  90 int _fixsquid() {
  91         FILE *squidreadfile;
  92         FILE *squidwritefile;
  93         FILE *aclreadfile;
  94         char hostname[STRING_SIZE] = "";
  95         char domainname[STRING_SIZE] = "";
  96         char squidtemp[STRING_SIZE];
  97         struct keyvalue *kv = initkeyvalues();
  98         int already_upgraded = 0;
  99         int updated = 0;
 100
 101         if (!(squidreadfile = fopen ("/harddisk" CONFIG_ROOT "/proxy/squid.conf", "r"))) return 1;
 102         if (!(squidwritefile = fopen ("/harddisk" CONFIG_ROOT "/proxy/squid.conf.new", "w")))
 103         {
 104                 fclose(squidreadfile);
 105                 return 1;
 106         }
 107
 108         if (!(readkeyvalues(kv, "/harddisk" CONFIG_ROOT "/main/settings")))
 109         {
 110                 fclose (squidwritefile);
 111                 fclose (squidreadfile);
 112                 freekeyvalues(kv);
 113                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
 114                 return 1;
 115         }
 116
 117         findkey(kv, "HOSTNAME", hostname);
 118         findkey(kv, "DOMAINNAME", domainname);
 119         freekeyvalues(kv);
 120
 121         while (fgets (squidtemp, STRING_SIZE, squidreadfile) != NULL) {
 122                 /* this will fail if we've already been upgraded, which is ok */
 123                 if (!strncmp(squidtemp, "reply_body_max_size 0 KB", 24)) {
 124                         sprintf(squidtemp, "reply_body_max_size 0 allow all\n");
 125                 }
 126                 if (!strncmp(squidtemp, "cache_store_log /var/log/squid/store.log", 40)) {
 127                         sprintf(squidtemp, "cache_store_log none\n");
 128                 }
 129                 fputs(squidtemp, squidwritefile);
 130
 131                 /* so for us developers we skip already upgraded squiddies */
 132                 if (!strncmp(squidtemp, "visible_hostname", 16)) {
 133                         already_upgraded = 1;
 134                 }
 135
 136                 /* Check for the new acl's */
 137                 if (!strncmp(squidtemp, "__GREEN_IP__", 12)) {
 138                         updated = 1;
 139                 }
 140         }
 141         if (!already_upgraded) {
 142                 sprintf(squidtemp, "visible_hostname %s.%s\n", hostname, domainname);
 143                 fputs(squidtemp, squidwritefile);
 144         }
 145
 146         fclose (squidwritefile);
 147         fclose (squidreadfile);
 148
 149         rename ("/harddisk" CONFIG_ROOT "/proxy/squid.conf.new",
 150                 "/harddisk" CONFIG_ROOT "/proxy/squid.conf");
 151
 152         replace("/harddisk" CONFIG_ROOT "/proxy/squid.conf", "cache_dir ufs", "cache_dir aufs");
 153
 154         if (!updated) {
 155                 rename ("/harddisk" CONFIG_ROOT "/proxy/acl",
 156                         "/harddisk" CONFIG_ROOT "/proxy/acl.old");
 157                 rename ("/harddisk" CONFIG_ROOT "/proxy/acl-1.4",
 158                         "/harddisk" CONFIG_ROOT "/proxy/acl");
 159         } else {
 160                 if (!(aclreadfile = fopen ("/harddisk" CONFIG_ROOT "/proxy/acl", "r"))) {
 161                         rename ("/harddisk" CONFIG_ROOT "/proxy/acl-1.4",
 162                                 "/harddisk" CONFIG_ROOT "/proxy/acl");
 163                 } else {
 164                         unlink ("/harddisk" CONFIG_ROOT "/proxy/acl-1.4");
 165                         fclose(aclreadfile);
 166                 }
 167         }
 168
 169         chown  ("/harddisk" CONFIG_ROOT "/proxy/squid.conf", 99, 99);
 170         chown  ("/harddisk" CONFIG_ROOT "/proxy/acl", 99, 99);
 171         return 0;
 172 }
 173
 174 int _fixeagleusb() {
 175         FILE *eaglereadfile;
 176         FILE *eaglewritefile;
 177         char eagletemp[STRING_SIZE];
 178         int already_upgraded = 0;
 179
 180         if (!(eaglereadfile  = fopen ("/harddisk" CONFIG_ROOT "/eagle-usb/eagle-usb.conf", "r"))) return 1;
 181         if (!(eaglewritefile = fopen ("/harddisk" CONFIG_ROOT "/eagle-usb/eagle-usb.conf.new", "w")))
 182         {
 183                 fclose(eaglereadfile);
 184                 return 1;
 185         }
 186
 187         while (fgets (eagletemp, STRING_SIZE, eaglereadfile) != NULL) {
 188                 /* so for us developers we skip already upgraded configs */
 189                 if (!strncmp(eagletemp, "<eaglectrl>", 11)) {
 190                         already_upgraded = 1;
 191                 }
 192         }
 193
 194         rewind(eaglereadfile);
 195         if (!already_upgraded)
 196                 fprintf(eaglewritefile, "<eaglectrl>\n");
 197         while (fgets (eagletemp, STRING_SIZE, eaglereadfile) != NULL)
 198                 fputs(eagletemp, eaglewritefile);
 199         if (!already_upgraded)
 200                 fprintf(eaglewritefile, "</eaglectrl>\n");
 201
 202         fclose (eaglewritefile);
 203         fclose (eaglereadfile);
 204
 205         rename ("/harddisk" CONFIG_ROOT "/eagle-usb/eagle-usb.conf.new",
 206                 "/harddisk" CONFIG_ROOT "/eagle-usb/eagle-usb.conf");
 207
 208         replace("/harddisk" CONFIG_ROOT "/eagle-usb/eagle-usb.conf", "Linetype=00000001", "Linetype=0A");
 209
 210         chown  ("/harddisk" CONFIG_ROOT "/eagle-usb/eagle-usb.conf", 99, 99);
 211         unlink("/harddisk" CONFIG_ROOT "/eagle-usb/dsp_code_pots.bin");
 212         unlink("/harddisk" CONFIG_ROOT "/eagle-usb/dsp_code_isdn.bin");
 213         return 0;
 214 }
 215
 216 int _fixdhcp_30() {
 217         FILE *dhcpreadfile;
 218         FILE *dhcpwritefile;
 219         char dhcptemp[STRING_SIZE];
 220
 221         if (!(dhcpreadfile = fopen ("/harddisk" CONFIG_ROOT "/dhcp/dhcpd.conf", "r"))) return 1;
 222         if (!(dhcpwritefile = fopen ("/harddisk" CONFIG_ROOT "/dhcp/dhcpd.conf.new", "w")))
 223         {
 224                 fclose(dhcpreadfile);
 225                 return 1;
 226         }
 227         fprintf (dhcpwritefile, "authoritative;\n");
 228         fprintf (dhcpwritefile, "deny bootp;\n");
 229         fprintf (dhcpwritefile, "ddns-update-style none;\n");
 230         while (fgets (dhcptemp, STRING_SIZE, dhcpreadfile) != NULL) {
 231                 int write = 1;
 232
 233                 /* so for us developers we skip already upgraded dhcp files */
 234                 if (!strncmp(dhcptemp, "authoritative", 13)) {
 235                         write = 0;
 236                 }
 237                 /* so for us developers we skip already upgraded dhcp files */
 238                 if (!strncmp(dhcptemp, "ddns-update-style", 17)) {
 239                         write = 0;
 240                 }
 241                 /* so for us developers we skip already upgraded dhcp files */
 242                 if (!strncmp(dhcptemp, "deny bootp", 10)) {
 243                         write = 0;
 244                 }
 245
 246                 if (write)
 247                         fputs(dhcptemp, dhcpwritefile);
 248         }
 249
 250         fclose(dhcpreadfile);
 251         fclose(dhcpwritefile);
 252
 253         rename ("/harddisk" CONFIG_ROOT "/dhcp/dhcpd.conf.new",
 254                 "/harddisk" CONFIG_ROOT "/dhcp/dhcpd.conf");
 255         chown  ("/harddisk" CONFIG_ROOT "/dhcp/dhcpd.conf", 99, 99);
 256
 257         /* This one will get converted again furthur down */
 258         replace("/harddisk" CONFIG_ROOT "/dhcp/settings", "WINS=", "WINS1=");
 259
 260         replace("/harddisk" CONFIG_ROOT "/dhcp/settings", "START_ADDR=", "START_ADDR_GREEN=");
 261         replace("/harddisk" CONFIG_ROOT "/dhcp/settings", "END_ADDR=", "END_ADDR_GREEN=");
 262         replace("/harddisk" CONFIG_ROOT "/dhcp/settings", "DOMAIN_NAME=", "DOMAIN_NAME_GREEN=");
 263         replace("/harddisk" CONFIG_ROOT "/dhcp/settings", "DEFAULT_LEASE_TIME=", "DEFAULT_LEASE_TIME_GREEN=");
 264         replace("/harddisk" CONFIG_ROOT "/dhcp/settings", "MAX_LEASE_TIME=", "MAX_LEASE_TIME_GREEN=");
 265         replace("/harddisk" CONFIG_ROOT "/dhcp/settings", "DNS1=", "DNS1_GREEN=");
 266         replace("/harddisk" CONFIG_ROOT "/dhcp/settings", "DNS2=", "DNS2_GREEN=");
 267         replace("/harddisk" CONFIG_ROOT "/dhcp/settings", "WINS1=", "WINS1_GREEN=");
 268         replace("/harddisk" CONFIG_ROOT "/dhcp/settings", "WINS2=", "WINS2_GREEN=");
 269         replace("/harddisk" CONFIG_ROOT "/dhcp/settings", "ENABLE=", "ENABLE_GREEN=");
 270         replace("/harddisk" CONFIG_ROOT "/dhcp/settings", "range dynamic-bootp", "range");
 271         chown  ("/harddisk" CONFIG_ROOT "/dhcp/settings", 99, 99);
 272
 273         if ((dhcpreadfile = fopen ("/harddisk" CONFIG_ROOT "/dhcp/enable", "r")))
 274         {
 275                 fclose(dhcpreadfile);
 276                 rename ("/harddisk" CONFIG_ROOT "/dhcp/enable",
 277                         "/harddisk" CONFIG_ROOT "/dhcp/enable_green");
 278                 chown  ("/harddisk" CONFIG_ROOT "/dhcp/enable_green", 99, 99);
 279         }
 280
 281         return 0;
 282 }
 283
 284 int _add_sshd_user() {
 285         mysystem("/bin/chroot /harddisk /usr/sbin/userdel sshd");
 286         mysystem("/bin/chroot /harddisk /usr/sbin/groupdel sshd");
 287         mysystem("/bin/chroot /harddisk /usr/sbin/groupadd -g 74 sshd");
 288         mysystem("/bin/chroot /harddisk /usr/sbin/useradd  -u 74 -g sshd -d /var/empty/sshd -s /bin/false -M sshd");
 289
 290         return 0;
 291 }
 292
 293 int _add_dnsmasq_user() {
 294         mysystem("/bin/chroot /harddisk /usr/sbin/userdel dnsmasq");
 295         mysystem("/bin/chroot /harddisk /usr/sbin/groupdel dnsmasq");
 296         mysystem("/bin/chroot /harddisk /usr/sbin/groupadd -g 103 dnsmasq");
 297         mysystem("/bin/chroot /harddisk /usr/sbin/useradd  -u 103 -g dnsmasq -d / -s /bin/false -M dnsmasq");
 298
 299         return 0;
 300 }
 301
 302 int _add_cron_user() {
 303         mysystem("/bin/chroot /harddisk /usr/sbin/userdel cron");
 304         mysystem("/bin/chroot /harddisk /usr/sbin/groupdel cron");
 305         mysystem("/bin/chroot /harddisk /usr/sbin/groupadd -g 104 cron");
 306         mysystem("/bin/chroot /harddisk /usr/sbin/useradd  -u 104 -g cron -d / -s /bin/false -M cron");
 307
 308         return 0;
 309 }
 310
 311 int _add_sysklogd_user() {
 312         mysystem("/bin/chroot /harddisk /usr/sbin/userdel syslogd");
 313         mysystem("/bin/chroot /harddisk /usr/sbin/groupdel syslogd");
 314         mysystem("/bin/chroot /harddisk /usr/sbin/groupadd -g 105 syslogd");
 315         mysystem("/bin/chroot /harddisk /usr/sbin/useradd  -u 105 -g syslogd -d / -s /bin/false -M syslogd");
 316         mysystem("/bin/chroot /harddisk /usr/sbin/userdel klogd");
 317         mysystem("/bin/chroot /harddisk /usr/sbin/groupdel klogd");
 318         mysystem("/bin/chroot /harddisk /usr/sbin/groupadd -g 106 klogd");
 319         mysystem("/bin/chroot /harddisk /usr/sbin/useradd  -u 106 -g klogd -d / -s /bin/false -M klogd");
 320
 321         return 0;
 322 }
 323
 324 int _del_setup_user() {
 325         mysystem("/bin/chroot /harddisk /usr/sbin/userdel setup");
 326
 327         return 0;
 328 }
 329
 330 int _create_nobody_dir(){
 331         mysystem("/bin/chroot /harddisk /usr/sbin/usermod -d /home/nobody nobody");
 332
 333         return 0;
 334 }
 335
 336 int _del_useless_user_group()
 337 {
 338         mysystem("/bin/chroot /harddisk /usr/sbin/userdel games");
 339         mysystem("/bin/chroot /harddisk /usr/sbin/groupdel games");
 340         mysystem("/bin/chroot /harddisk /usr/sbin/userdel news");
 341         mysystem("/bin/chroot /harddisk /usr/sbin/groupdel news");
 342         mysystem("/bin/chroot /harddisk /usr/sbin/userdel ftp");
 343         mysystem("/bin/chroot /harddisk /usr/sbin/userdel gopher");
 344         mysystem("/bin/chroot /harddisk /usr/sbin/userdel lp");
 345         mysystem("/bin/chroot /harddisk /usr/sbin/userdel uucp");
 346         mysystem("/bin/chroot /harddisk /usr/sbin/userdel adm");
 347         mysystem("/bin/chroot /harddisk /usr/sbin/groupdel adm");
 348         mysystem("/bin/chroot /harddisk /usr/sbin/userdel operator");
 349         mysystem("/bin/chroot /harddisk /usr/sbin/userdel sync");
 350         mysystem("/bin/chroot /harddisk /usr/sbin/userdel shutdown");
 351         mysystem("/bin/chroot /harddisk /usr/sbin/userdel halt");
 352         mysystem("/bin/chroot /harddisk /usr/sbin/groupdel man");
 353         return 0;
 354 }
 355
 356 void _del_pulsardsl_dir()
 357 {
 358         mysystem("/bin/chroot /harddisk /bin/rm -rf " CONFIG_ROOT "/pulsardsl");
 359 }
 360
 361 void _del_fritzdsl_dir()
 362 {
 363         mysystem("/bin/chroot /harddisk /bin/rm -rf " CONFIG_ROOT "/fritzdsl");
 364 }
 365
 366 int _convert_vpn() {
 367         int count=1;
 368         FILE *vpn1, *vpn2;
 369         char vpnip[STRING_SIZE] = "";
 370         char greennetaddr[STRING_SIZE] = "";
 371         struct keyvalue *kv = initkeyvalues();
 372         char vpnsrctemp[STRING_SIZE], vpndsttemp[STRING_SIZE];
 373         char *name, *left, *left_nexthop, *left_subnet, *right, *right_nexthop, *right_subnet, *secret, *enabled, *compression;
 374
 375         if (!(vpn1 = fopen ("/harddisk" CONFIG_ROOT "/vpn/config", "r"))) return 1;
 376         if (!(vpn2 = fopen ("/harddisk" CONFIG_ROOT "/vpn/config.new", "w")))
 377         {
 378                 fclose(vpn1);
 379                 return 1;
 380         }
 381
 382         if (!(readkeyvalues(kv, "/harddisk" CONFIG_ROOT "/ethernet/settings")))
 383         {
 384                 fclose (vpn1);
 385                 fclose (vpn2);
 386                 freekeyvalues(kv);
 387                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
 388                 return 0;
 389         }
 390
 391         findkey(kv, "GREEN_NETADDRESS", greennetaddr);
 392         freekeyvalues(kv);
 393
 394         kv = initkeyvalues();
 395         if (!(readkeyvalues(kv, "/harddisk" CONFIG_ROOT "/vpn/settings")))
 396         {
 397                 fclose (vpn1);
 398                 fclose (vpn2);
 399                 freekeyvalues(kv);
 400                 errorbox(ctr[TR_UNABLE_TO_OPEN_SETTINGS_FILE]);
 401                 return 0;
 402         }
 403
 404         /* if no VPN_IP is defined, we must turn it off to force the user
 405          * to enter a value once upgraded */
 406         findkey(kv, "VPN_IP", vpnip);
 407         if (strlen(vpnip) == 0) {
 408                 replacekeyvalue(kv, "ENABLED", "off");
 409                 writekeyvalues(kv, "/harddisk" CONFIG_ROOT "/vpn/settings");
 410         }
 411         freekeyvalues(kv);
 412
 413         while (fgets (vpnsrctemp, STRING_SIZE, vpn1) != NULL) {
 414                 if (isdigit (vpnsrctemp[0])) {
 415                         /* Already converted to new format */
 416                         fputs(vpnsrctemp, vpn2);
 417                         continue;
 418                 }
 419
 420                 name          = NULL;
 421                 left          = NULL;
 422                 left_nexthop  = NULL;
 423                 left_subnet   = NULL;
 424                 right         = NULL;
 425                 right_nexthop = NULL;
 426                 right_subnet  = NULL;
 427                 secret        = NULL;
 428                 enabled       = NULL;
 429                 compression   = NULL;
 430
 431                 if (vpnsrctemp[strlen(vpnsrctemp) - 1] == '\n')
 432                         vpnsrctemp[strlen(vpnsrctemp) - 1] = '\0';
 433                 name          = strtok (vpnsrctemp, ",");
 434                 left          = strtok (NULL, ",");
 435                 left_nexthop  = strtok (NULL, ",");
 436                 left_subnet   = strtok (NULL, ",");
 437                 right         = strtok (NULL, ",");
 438                 right_nexthop = strtok (NULL, ",");
 439                 right_subnet  = strtok (NULL, ",");
 440                 secret        = strtok (NULL, ",");
 441                 enabled       = strtok (NULL, ",");
 442                 compression   = strtok (NULL, ",");
 443                 if (!(name && left && left_subnet &&
 444                         right && right_subnet &&
 445                         secret && enabled && compression ))
 446                         continue;
 447
 448                 /* Try and guess what side IPCop is on; defaults to left */
 449                 if (strstr(greennetaddr, right_subnet)) {
 450                         sprintf (vpndsttemp, "%d,%s,%s,,net,psk,%s,right,,%s,,%s,%s,,%s,,,,,,,,,,,,,RED\n",
 451                                                         count, enabled, name, secret, right_subnet,
 452                                                         left, left_subnet, compression);
 453                 } else {
 454                         sprintf (vpndsttemp, "%d,%s,%s,,net,psk,%s,left,,%s,,%s,%s,,%s,,,,,,,,,,,,,RED\n",
 455                                                         count, enabled, name, secret, left_subnet,
 456                                                         right, right_subnet, compression);
 457                 }
 458                 fputs(vpndsttemp, vpn2);
 459
 460                 count++;
 461         }
 462
 463         /* Close source and destination vpn files */
 464         fclose (vpn1);
 465         fclose (vpn2);
 466
 467         /* Move the new vpn file */
 468         rename ("/harddisk" CONFIG_ROOT "/vpn/config.new",
 469                 "/harddisk" CONFIG_ROOT "/vpn/config");
 470         chown  ("/harddisk" CONFIG_ROOT "/vpn/config", 99, 99);
 471
 472         return 0;
 473 }
 474
 475 void _convert_ppp_settings_V140() {
 476         DIR *dirp;
 477         struct dirent *dp;
 478         char filename[STRING_SIZE];
 479
 480         dirp = opendir( "/harddisk" CONFIG_ROOT "/ppp" );
 481         while ( (dp = readdir( dirp )) != NULL ) {
 482                 if ( strstr( dp->d_name, "settings" ) == dp->d_name ) {
 483                         snprintf (filename, STRING_SIZE-1, "%s/%s",
 484                                 "/harddisk" CONFIG_ROOT "/ppp", dp->d_name);
 485                         replace (filename, "PERSISTENT=on", "RECONNECTION=persistent");
 486                         replace (filename, "DIALONDEMAND=on", "RECONNECTION=dialondemand");
 487                         replace (filename, "MODULATION=GDTM", "MODULATION=GDMT");
 488                         chown (filename, 99, 99);
 489                 }
 490         }
 491         (void) closedir( dirp );
 492 }
 493
 494 void _convert_net_settings_V140(){
 495         replace ("/harddisk" CONFIG_ROOT "/ethernet/settings", "eepro100", "e100");
 496         chown   ("/harddisk" CONFIG_ROOT "/ethernet/settings", 99, 99);
 497 }
 498
 499 void _convert_keymap() {
 500         replace("/harddisk" CONFIG_ROOT "/main/settings", "KEYMAP=/lib/kbd", "KEYMAP=/usr/share/kbd");
 501         replace("/harddisk" CONFIG_ROOT "/main/settings", ".kmap.gz", ".map.gz");
 502         chown  ("/harddisk" CONFIG_ROOT "/main/settings", 99, 99);
 503 }
 504
 505 void _convert_speedtouch() {
 506         FILE *speedtchbootfile;
 507         FILE *speedtchfirmfile;
 508
 509         if (( speedtchfirmfile = fopen ("/harddisk" CONFIG_ROOT "/alcatelusb/firmware.v4.bin", "r")))
 510         {
 511                 fclose (speedtchfirmfile);
 512                 if  ((speedtchbootfile = fopen ("/harddisk" CONFIG_ROOT "/alcatelusb/boot.v4.bin", "r")))  {
 513                         fclose (speedtchbootfile);
 514                         system("/bin/cat /harddisk" CONFIG_ROOT "/alcatelusb/boot.v4.bin "
 515                                 "/harddisk" CONFIG_ROOT "/alcatelusb/firmware.v4.bin"
 516                                 "> /harddisk" CONFIG_ROOT "/alcatelusb/firmware.v4_b.bin");
 517                         remove ("/harddisk" CONFIG_ROOT "/alcatelusb/boot.v4.bin");
 518                         remove ("/harddisk" CONFIG_ROOT "/alcatelusb/firmware.v4.bin");
 519                         chown ("/harddisk" CONFIG_ROOT "/alcatelusb/firmware.v4_b.bin", 99, 99);
 520                 }
 521         }
 522
 523         if (( speedtchfirmfile = fopen ("/harddisk" CONFIG_ROOT "/alcatelusb/firmware.v123.bin", "r"))) {
 524                 fclose (speedtchfirmfile);
 525                 system("/bin/cat /harddisk" CONFIG_ROOT "/alcatelusb/boot.v123.bin "
 526                         "/harddisk" CONFIG_ROOT "/alcatelusb/firmware.v123.bin"
 527                         "> /harddisk" CONFIG_ROOT "/alcatelusb/firmware.v0123.bin");
 528                 remove ("/harddisk" CONFIG_ROOT "/alcatelusb/firmware.v123.bin");
 529         }
 530
 531         remove ("/harddisk" CONFIG_ROOT "/alcatelusb/boot.v123.bin");
 532
 533         rename ("/harddisk" CONFIG_ROOT "/alcatelusb/mgmt.o", "/harddisk" CONFIG_ROOT "/alcatelusb/firmware.v0123.bin");
 534         chown ("/harddisk" CONFIG_ROOT "/alcatelusb/firmware.v0123.bin", 99, 99);
 535 }
 536
 537 void _convert_isapnp() {
 538         FILE *isapnpfile;
 539
 540         mkdir ("/harddisk" CONFIG_ROOT "/isapnp", S_IRWXU|S_IRWXG|S_IRWXO );
 541         if (( isapnpfile = fopen ("/harddisk/etc/isapnp.conf", "r"))) {
 542                 fclose (isapnpfile);
 543                 rename ("/harddisk/etc/isapnp.conf", "/harddisk" CONFIG_ROOT "/isapnp/isapnp.conf");
 544         } else {
 545                 if (( isapnpfile = fopen ("/harddisk" CONFIG_ROOT "/isapnp/isapnp.conf", "r"))) {
 546                         fclose(isapnpfile);
 547                 } else {
 548                         isapnpfile = fopen ("/harddisk" CONFIG_ROOT "/isapnp/isapnp.conf", "w");
 549                         fclose(isapnpfile);
 550                 }
 551         }
 552 }
 553
 554 int upgrade_v130_v140() {
 555         _del_setup_user();
 556         _del_useless_user_group();
 557         _add_logwatch_user();
 558         _add_sshd_user();
 559         _add_dnsmasq_user();
 560         _add_cron_user();
 561         _add_sysklogd_user();
 562         _del_pulsardsl_dir();
 563         _del_fritzdsl_dir();
 564         _convert_vpn();
 565         _handledomainname();
 566         _fixsquid();
 567         _fixeagleusb();
 568         _create_nobody_dir();
 569         _convert_ppp_settings_V140();
 570         _convert_net_settings_V140();
 571         _fixdhcp_30();
 572         _convert_keymap();
 573         _convert_speedtouch();
 574         _convert_isapnp();
 575
 576         return 0;
 577 }