1 files changed, 4 insertions, 2 deletions

diff --git a/noncore/settings/networksettings/ppp/modem.cpp b/noncore/settings/networksettings/ppp/modem.cpp
index 7b2e2a3..17ada9b 100644
--- a/noncore/settings/networksettings/ppp/modem.cpp
+++ b/noncore/settings/networksettings/ppp/modem.cpp
@@ -579,386 +579,388 @@ QString Modem::parseModemSpeed(const QString &s) {
 int Modem::lockdevice() {
   int fd;
   char newlock[80]=""; // safe
 
   if(!_pppdata->modemLockFile()) {
     odebug << "The user doesn't want a lockfile." << oendl;
     return 0;
   }
 
   if (modem_is_locked)
     return 1;
 
   QString lockfile = LOCK_DIR"/LCK..";
   lockfile += _pppdata->modemDevice().mid(5); // append everything after /dev/
 
   if(access(QFile::encodeName(lockfile), F_OK) == 0) {
 //    if ((fd = Requester::rq->
 if ((fd = openLockfile(QFile::encodeName(lockfile), O_RDONLY)) >= 0) {
       // Mario: it's not necessary to read more than lets say 32 bytes. If
       // file has more than 32 bytes, skip the rest
       char oldlock[33]; // safe
       int sz = read(fd, &oldlock, 32);
       close (fd);
       if (sz <= 0)
         return 1;
       oldlock[sz] = '\0';
 
       odebug << "Device is locked by: " << oldlock << "" << oendl;
 
       int oldpid;
       int match = sscanf(oldlock, "%d", &oldpid);
 
       // found a pid in lockfile ?
       if (match < 1 || oldpid <= 0)
         return 1;
 
       // check if process exists
       if (kill((pid_t)oldpid, 0) == 0 || errno != ESRCH)
         return 1;
 
       odebug << "lockfile is stale" << oendl;
     }
   }
 
   fd = openLockfile(_pppdata->modemDevice(),O_WRONLY|O_TRUNC|O_CREAT);
   if(fd >= 0) {
     sprintf(newlock,"%010d\n", getpid());
     odebug << "Locking Device: " << newlock << "" << oendl;
 
     write(fd, newlock, strlen(newlock));
     close(fd);
     modem_is_locked=true;
 
     return 0;
   }
 
   return -1;
 
 }
 
 
 // UnLock modem device
 void Modem::unlockdevice() {
   if (modem_is_locked) {
     odebug << "UnLocking Modem Device" << oendl;
     close(modemfd);
     modemfd = -1;
     unlink(lockfile);
     lockfile[0] = '\0';
     modem_is_locked=false;
   }
 }
 
 int Modem::openLockfile( QString lockfile, int flags)
 {
     int fd;
     int mode;
     flags = O_RDONLY;
     if(flags == O_WRONLY|O_TRUNC|O_CREAT)
         mode = 0644;
     else
         mode = 0;
 
     lockfile = LOCK_DIR;
     lockfile += "/LCK..";
     lockfile += device.right( device.length() - device.findRev("/") -1 );
     odebug << "lockfile >" << lockfile.latin1() << "<" << oendl;
     // TODO:
     //   struct stat st;
     //   if(stat(lockfile.data(), &st) == -1) {
     //     if(errno == EBADF)
     //       return -1;
     //   } else {
     //     // make sure that this is a regular file
     //     if(!S_ISREG(st.st_mode))
     //       return -1;
     //   }
     if ((fd = open(lockfile, flags, mode)) == -1) {
         odebug << "error opening lockfile!" << oendl;
         lockfile = QString::null;
         fd = open(DEVNULL, O_RDONLY);
     } else
         fchown(fd, 0, 0);
     return fd;
 }
 
 
 
 void alarm_handler(int) {
   //  fprintf(stderr, "alarm_handler(): Received SIGALRM\n");
 
   // jump
   siglongjmp(jmp_buffer, 1);
 }
 
 
 const char* Modem::authFile(Auth method, int version) {
   switch(method|version) {
   case PAP|Original:
     return PAP_AUTH_FILE;
     break;
   case PAP|New:
     return PAP_AUTH_FILE".new";
     break;
   case PAP|Old:
     return PAP_AUTH_FILE".old";
     break;
   case CHAP|Original:
     return CHAP_AUTH_FILE;
     break;
   case CHAP|New:
     return CHAP_AUTH_FILE".new";
     break;
   case CHAP|Old:
     return CHAP_AUTH_FILE".old";
     break;
   default:
     return 0L;
   }
 }
 
 
 bool Modem::createAuthFile(Auth method, const char *username, const char *password) {
   const char *authfile, *oldName, *newName;
   char line[100];
   char regexp[2*MaxStrLen+30];
   regex_t preg;
 
   if(!(authfile = authFile(method)))
     return false;
 
   if(!(newName = authFile(method, New)))
     return false;
 
   // look for username, "username" or 'username'
   // if you modify this RE you have to adapt regexp's size above
   snprintf(regexp, sizeof(regexp), "^[ \t]*%s[ \t]\\|^[ \t]*[\"\']%s[\"\']",
           username,username);
   MY_ASSERT(regcomp(&preg, regexp, 0) == 0);
 
   // copy to new file pap- or chap-secrets
   int old_umask = umask(0077);
   FILE *fout = fopen(newName, "w");
   if(fout) {
     // copy old file
     FILE *fin = fopen(authfile, "r");
     if(fin) {
       while(fgets(line, sizeof(line), fin)) {
         if(regexec(&preg, line, 0, 0L, 0) == 0)
            continue;
         fputs(line, fout);
       }
       fclose(fin);
     }
 
     // append user/pass pair
     fprintf(fout, "\"%s\"\t*\t\"%s\"\n", username, password);
     fclose(fout);
   }
 
   // restore umask
   umask(old_umask);
 
   // free memory allocated by regcomp
   regfree(&preg);
 
   if(!(oldName = authFile(method, Old)))
     return false;
 
   // delete old file if any
   unlink(oldName);
 
-  rename(authfile, oldName);
-  rename(newName, authfile);
+  if (rename(authfile, oldName) == -1)
+    return false;
+  if (rename(newName, authfile) == -1)
+    return false;
 
   return true;
 }
 
 
 bool Modem::removeAuthFile(Auth method) {
   const char *authfile, *oldName;
 
   if(!(authfile = authFile(method)))
     return false;
   if(!(oldName = authFile(method, Old)))
     return false;
 
   if(access(oldName, F_OK) == 0) {
     unlink(authfile);
     return (rename(oldName, authfile) == 0);
   } else
     return false;
 }
 
 
 bool Modem::setSecret(int method, const char* name, const char* password)
 {
 
     Auth auth;
     if(method == AUTH_PAPCHAP)
         return setSecret(AUTH_PAP, name, password) &&
             setSecret(AUTH_CHAP, name, password);
 
     switch(method) {
     case AUTH_PAP:
         auth = Modem::PAP;
         break;
     case AUTH_CHAP:
         auth = Modem::CHAP;
         break;
     default:
         return false;
     }
 
     return createAuthFile(auth, name, password);
 
 }
 
 bool Modem::removeSecret(int method)
 {
    Auth auth;
 
     switch(method) {
     case AUTH_PAP:
         auth = Modem::PAP;
         break;
     case AUTH_CHAP:
         auth = Modem::CHAP;
         break;
     default:
         return false;
     }
     return removeAuthFile( auth );
 }
 
 int checkForInterface()
 {
 // I don't know if Linux needs more initialization to get the ioctl to
 // work, pppd seems to hint it does.  But BSD doesn't, and the following
 // code should compile.
 #if (defined(HAVE_NET_IF_PPP_H) || defined(HAVE_LINUX_IF_PPP_H)) && !defined(__svr4__)
     int s, ok;
     struct ifreq ifr;
     //    extern char *no_ppp_msg;
 
     if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
         return 1;               /* can't tell */
 
     strlcpy(ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
     ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
     close(s);
 
     if (ok == -1) {
 // This is ifdef'd FreeBSD, because FreeBSD is the only BSD that supports
 // KLDs, the old LKM interface couldn't handle loading devices
 // dynamically, and thus can't load ppp support on the fly
 #ifdef __FreeBSD__
         // If we failed to load ppp support and don't have it already.
         if (kldload("if_ppp") == -1) {
             return -1;
         }
         return 0;
 #else
         return -1;
 #endif
     }
     return 0;
 #else
 // We attempt to use the SunOS/SysVr4 method and stat /dev/ppp
    struct stat buf;
 
    memset(&buf, 0, sizeof(buf));
    return stat("/dev/ppp", &buf);
 #endif
 }
 
 bool Modem::execpppd(const char *arguments) {
   char buf[MAX_CMDLEN];
   char *args[MaxArgs];
   pid_t pgrpid;
 
   if(modemfd<0)
     return false;
 
   _pppdExitStatus = -1;
 
   (void)::pipe( m_pppdLOG );
 
   switch(pppdPid = fork())
     {
     case -1:
       fprintf(stderr,"In parent: fork() failed\n");
       ::close(  m_pppdLOG[0] );
       ::close(  m_pppdLOG[1] );
       return false;
       break;
 
     case 0:
       // let's parse the arguments the user supplied into UNIX suitable form
       // that is a list of pointers each pointing to exactly one word
       strlcpy(buf, arguments);
       parseargs(buf, args);
       // become a session leader and let /dev/ttySx
       // be the controlling terminal.
       pgrpid = setsid();
 #ifdef TIOCSCTTY
       if(ioctl(modemfd, TIOCSCTTY, 0)<0)
         fprintf(stderr, "ioctl() failed.\n");
 #elif defined (TIOCSPGRP)
        if(ioctl(modemfd, TIOCSPGRP, &pgrpid)<0)
        fprintf(stderr, "ioctl() failed.\n");
 #endif
       if(tcsetpgrp(modemfd, pgrpid)<0)
         fprintf(stderr, "tcsetpgrp() failed.\n");
 
       ::close( m_pppdLOG[0] );
       ::setenv( "LANG", "C", 1 ); // overwrite
       dup2(m_pppdLOG[1], 11 ); // for logfd 11
       dup2(modemfd, 0);
       dup2(modemfd, 1);
 
 
       switch (checkForInterface()) {
         case 1:
           fprintf(stderr, "Cannot determine if kernel supports ppp.\n");
           break;
         case -1:
           fprintf(stderr, "Kernel does not support ppp, oops.\n");
           break;
         case 0:
           fprintf(stderr, "Kernel supports ppp alright.\n");
           break;
       }
 
       execve(pppdPath(), args, 0L);
       _exit(0);
       break;
 
     default:
       odebug << "In parent: pppd pid " << pppdPid << "\n" << oendl;
       close(modemfd);
 
       ::close( m_pppdLOG[1] );
       // set it to nonblocking io
       int flag = ::fcntl( m_pppdLOG[0], F_GETFL );
 
       if ( !(flag & O_NONBLOCK) ) {
           odebug << "Setting nonblocking io" << oendl;
           flag |= O_NONBLOCK;
           ::fcntl(m_pppdLOG[0], F_SETFL, flag );
       }
 
       delete m_modemDebug;
       m_modemDebug = new QSocketNotifier(m_pppdLOG[0], QSocketNotifier::Read, this );
       connect(m_modemDebug, SIGNAL(activated(int) ),
               this, SLOT(slotModemDebug(int) ) );
 
       modemfd = -1;
       m_pppdDev = QString::fromLatin1("ppp0");
       return true;
       break;
     }
 }
 
 
 bool Modem::killpppd() {