[BACK]Return to rcs.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / cvs

Diff for /src/usr.bin/cvs/rcs.c between version 1.109 and 1.110

version 1.109, 2005/12/08 18:56:10 version 1.110, 2005/12/10 20:27:45
Line 331 
Line 331 
                 return (NULL);                  return (NULL);
         }          }
   
         if ((rfp = (RCSFILE *)malloc(sizeof(*rfp))) == NULL) {          rfp = (RCSFILE *)xmalloc(sizeof(*rfp));
                 cvs_log(LP_ERRNO, "failed to allocate RCS file structure");  
                 rcs_errno = RCS_ERR_ERRNO;  
                 return (NULL);  
         }  
         memset(rfp, 0, sizeof(*rfp));          memset(rfp, 0, sizeof(*rfp));
   
         if ((rfp->rf_path = strdup(path)) == NULL) {          rfp->rf_path = xstrdup(path);
                 rcs_errno = RCS_ERR_ERRNO;  
                 cvs_log(LP_ERRNO, "failed to duplicate RCS file path");  
                 free(rfp);  
                 return (NULL);  
         }  
   
         rfp->rf_ref = 1;          rfp->rf_ref = 1;
         rfp->rf_flags = flags | RCS_SLOCK;          rfp->rf_flags = flags | RCS_SLOCK;
         rfp->rf_mode = fmode;          rfp->rf_mode = fmode;
Line 367 
Line 357 
                         return (NULL);                          return (NULL);
                 }                  }
   
                 rdp->rd_locker = strdup(lkr->rl_name);                  rdp->rd_locker = xstrdup(lkr->rl_name);
                 if (rdp->rd_locker == NULL) {  
                         rcs_close(rfp);  
                         return (NULL);  
                 }  
         }          }
   
         return (rfp);          return (rfp);
Line 407 
Line 393 
         while (!TAILQ_EMPTY(&(rfp->rf_access))) {          while (!TAILQ_EMPTY(&(rfp->rf_access))) {
                 rap = TAILQ_FIRST(&(rfp->rf_access));                  rap = TAILQ_FIRST(&(rfp->rf_access));
                 TAILQ_REMOVE(&(rfp->rf_access), rap, ra_list);                  TAILQ_REMOVE(&(rfp->rf_access), rap, ra_list);
                 free(rap->ra_name);                  xfree(rap->ra_name);
                 free(rap);                  xfree(rap);
         }          }
   
         while (!TAILQ_EMPTY(&(rfp->rf_symbols))) {          while (!TAILQ_EMPTY(&(rfp->rf_symbols))) {
                 rsp = TAILQ_FIRST(&(rfp->rf_symbols));                  rsp = TAILQ_FIRST(&(rfp->rf_symbols));
                 TAILQ_REMOVE(&(rfp->rf_symbols), rsp, rs_list);                  TAILQ_REMOVE(&(rfp->rf_symbols), rsp, rs_list);
                 rcsnum_free(rsp->rs_num);                  rcsnum_free(rsp->rs_num);
                 free(rsp->rs_name);                  xfree(rsp->rs_name);
                 free(rsp);                  xfree(rsp);
         }          }
   
         while (!TAILQ_EMPTY(&(rfp->rf_locks))) {          while (!TAILQ_EMPTY(&(rfp->rf_locks))) {
                 rlp = TAILQ_FIRST(&(rfp->rf_locks));                  rlp = TAILQ_FIRST(&(rfp->rf_locks));
                 TAILQ_REMOVE(&(rfp->rf_locks), rlp, rl_list);                  TAILQ_REMOVE(&(rfp->rf_locks), rlp, rl_list);
                 rcsnum_free(rlp->rl_num);                  rcsnum_free(rlp->rl_num);
                 free(rlp->rl_name);                  xfree(rlp->rl_name);
                 free(rlp);                  xfree(rlp);
         }          }
   
         if (rfp->rf_head != NULL)          if (rfp->rf_head != NULL)
Line 433 
Line 419 
                 rcsnum_free(rfp->rf_branch);                  rcsnum_free(rfp->rf_branch);
   
         if (rfp->rf_path != NULL)          if (rfp->rf_path != NULL)
                 free(rfp->rf_path);                  xfree(rfp->rf_path);
         if (rfp->rf_comment != NULL)          if (rfp->rf_comment != NULL)
                 free(rfp->rf_comment);                  xfree(rfp->rf_comment);
         if (rfp->rf_expand != NULL)          if (rfp->rf_expand != NULL)
                 free(rfp->rf_expand);                  xfree(rfp->rf_expand);
         if (rfp->rf_desc != NULL)          if (rfp->rf_desc != NULL)
                 free(rfp->rf_desc);                  xfree(rfp->rf_desc);
         free(rfp);          xfree(rfp);
 }  }
   
 /*  /*
Line 616 
Line 602 
                                 return (-1);                                  return (-1);
                         }                          }
   
                         if ((bp = malloc(MAXBSIZE)) == NULL) {                          bp = xmalloc(MAXBSIZE);
                                 cvs_log(LP_ERRNO, "failed to allocate memory");  
                                 close(from_fd);  
                                 close(to_fd);  
                                 return (-1);  
                         }  
   
                         while ((nread = read(from_fd, bp, MAXBSIZE)) > 0) {                          while ((nread = read(from_fd, bp, MAXBSIZE)) > 0) {
                                 if (write(to_fd, bp, nread) != nread)                                  if (write(to_fd, bp, nread) != nread)
                                         goto err;                                          goto err;
Line 635 
Line 615 
                                             rfp->rf_path);                                              rfp->rf_path);
                                 close(from_fd);                                  close(from_fd);
                                 close(to_fd);                                  close(to_fd);
                                 free(bp);                                  xfree(bp);
                                 return (-1);                                  return (-1);
                         }                          }
   
                         close(from_fd);                          close(from_fd);
                         close(to_fd);                          close(to_fd);
                         free(bp);                          xfree(bp);
   
                         if (unlink(fn) == -1) {                          if (unlink(fn) == -1) {
                                 cvs_log(LP_ERRNO,                                  cvs_log(LP_ERRNO,
Line 758 
Line 738 
                 }                  }
         }          }
   
         ap = (struct rcs_access *)malloc(sizeof(*ap));          ap = (struct rcs_access *)xmalloc(sizeof(*ap));
         if (ap == NULL) {          ap->ra_name = xstrdup(login);
                 rcs_errno = RCS_ERR_ERRNO;  
                 cvs_log(LP_ERRNO, "failed to allocate RCS access entry");  
                 return (-1);  
         }  
   
         ap->ra_name = strdup(login);  
         if (ap->ra_name == NULL) {  
                 cvs_log(LP_ERRNO, "failed to duplicate user name");  
                 free(ap);  
                 return (-1);  
         }  
   
         TAILQ_INSERT_TAIL(&(file->rf_access), ap, ra_list);          TAILQ_INSERT_TAIL(&(file->rf_access), ap, ra_list);
   
         /* not synced anymore */          /* not synced anymore */
Line 801 
Line 769 
         }          }
   
         TAILQ_REMOVE(&(file->rf_access), ap, ra_list);          TAILQ_REMOVE(&(file->rf_access), ap, ra_list);
         free(ap->ra_name);          xfree(ap->ra_name);
         free(ap);          xfree(ap);
   
         /* not synced anymore */          /* not synced anymore */
         file->rf_flags &= ~RCS_SYNCED;          file->rf_flags &= ~RCS_SYNCED;
Line 834 
Line 802 
                 }                  }
         }          }
   
         if ((symp = (struct rcs_sym *)malloc(sizeof(*symp))) == NULL) {          symp = (struct rcs_sym *)xmalloc(sizeof(*symp));
                 rcs_errno = RCS_ERR_ERRNO;          symp->rs_name = xstrdup(sym);
                 cvs_log(LP_ERRNO, "failed to allocate RCS symbol");  
                 return (-1);  
         }  
   
         if ((symp->rs_name = strdup(sym)) == NULL) {  
                 rcs_errno = RCS_ERR_ERRNO;  
                 cvs_log(LP_ERRNO, "failed to duplicate symbol");  
                 free(symp);  
                 return (-1);  
         }  
   
         if ((symp->rs_num = rcsnum_alloc()) == NULL) {          if ((symp->rs_num = rcsnum_alloc()) == NULL) {
                 free(symp->rs_name);                  xfree(symp->rs_name);
                 free(symp);                  xfree(symp);
                 return (-1);                  return (-1);
         }          }
         rcsnum_cpy(snum, symp->rs_num, 0);          rcsnum_cpy(snum, symp->rs_num, 0);
Line 889 
Line 846 
         }          }
   
         TAILQ_REMOVE(&(file->rf_symbols), symp, rs_list);          TAILQ_REMOVE(&(file->rf_symbols), symp, rs_list);
         free(symp->rs_name);          xfree(symp->rs_name);
         rcsnum_free(symp->rs_num);          rcsnum_free(symp->rs_num);
         free(symp);          xfree(symp);
   
         /* not synced anymore */          /* not synced anymore */
         file->rf_flags &= ~RCS_SYNCED;          file->rf_flags &= ~RCS_SYNCED;
Line 1016 
Line 973 
                 }                  }
         }          }
   
         if ((lkp = (struct rcs_lock *)malloc(sizeof(*lkp))) == NULL) {          lkp = (struct rcs_lock *)xmalloc(sizeof(*lkp));
                 rcs_errno = RCS_ERR_ERRNO;          lkp->rl_name = xstrdup(user);
                 cvs_log(LP_ERRNO, "failed to allocate RCS lock");  
                 return (-1);  
         }  
   
         lkp->rl_name = strdup(user);  
         if (lkp->rl_name == NULL) {  
                 cvs_log(LP_ERRNO, "failed to duplicate user name");  
                 free(lkp);  
                 return (-1);  
         }  
   
         if ((lkp->rl_num = rcsnum_alloc()) == NULL) {          if ((lkp->rl_num = rcsnum_alloc()) == NULL) {
                 free(lkp->rl_name);                  xfree(lkp->rl_name);
                 free(lkp);                  xfree(lkp);
                 return (-1);                  return (-1);
         }          }
         rcsnum_cpy(rev, lkp->rl_num, 0);          rcsnum_cpy(rev, lkp->rl_num, 0);
Line 1070 
Line 1016 
   
         TAILQ_REMOVE(&(file->rf_locks), lkp, rl_list);          TAILQ_REMOVE(&(file->rf_locks), lkp, rl_list);
         rcsnum_free(lkp->rl_num);          rcsnum_free(lkp->rl_num);
         free(lkp->rl_name);          xfree(lkp->rl_name);
         free(lkp);          xfree(lkp);
   
         /* not synced anymore */          /* not synced anymore */
         file->rf_flags &= ~RCS_SYNCED;          file->rf_flags &= ~RCS_SYNCED;
Line 1100 
Line 1046 
 {  {
         char *tmp;          char *tmp;
   
         if ((tmp = strdup(desc)) == NULL)          tmp = xstrdup(desc);
                 return (-1);  
   
         if (file->rf_desc != NULL)          if (file->rf_desc != NULL)
                 free(file->rf_desc);                  xfree(file->rf_desc);
         file->rf_desc = tmp;          file->rf_desc = tmp;
         file->rf_flags &= ~RCS_SYNCED;          file->rf_flags &= ~RCS_SYNCED;
   
Line 1157 
Line 1101 
 {  {
         char *tmp;          char *tmp;
   
         if ((tmp = strdup(comment)) == NULL)          tmp = xstrdup(comment);
                 return (-1);  
   
         if (file->rf_comment != NULL)          if (file->rf_comment != NULL)
                 free(file->rf_comment);                  xfree(file->rf_comment);
         file->rf_comment = tmp;          file->rf_comment = tmp;
         file->rf_flags &= ~RCS_SYNCED;          file->rf_flags &= ~RCS_SYNCED;
   
Line 1344 
Line 1286 
                         bp = cvs_buf_release(rbuf);                          bp = cvs_buf_release(rbuf);
                         rbuf = cvs_patchfile((char *)bp, (char *)rdp->rd_text,                          rbuf = cvs_patchfile((char *)bp, (char *)rdp->rd_text,
                             rcs_patch_lines);                              rcs_patch_lines);
                         free(bp);                          xfree(bp);
                         if (rbuf == NULL)                          if (rbuf == NULL)
                                 break;                                  break;
                 } while (rcsnum_cmp(crev, rev, 0) != 0);                  } while (rcsnum_cmp(crev, rev, 0) != 0);
Line 1381 
Line 1323 
                         }                          }
                         cvs_freelines(lines);                          cvs_freelines(lines);
                 }                  }
                 free(bp);                  xfree(bp);
         }          }
   
         return (dbuf);          return (dbuf);
Line 1448 
Line 1390 
                 return (-1);                  return (-1);
         }          }
   
         if ((rdp = (struct rcs_delta *)malloc(sizeof(*rdp))) == NULL) {          rdp = (struct rcs_delta *)xmalloc(sizeof(*rdp));
                 rcs_errno = RCS_ERR_ERRNO;  
                 rcsnum_free(old);  
                 return (-1);  
         }  
         memset(rdp, 0, sizeof(*rdp));          memset(rdp, 0, sizeof(*rdp));
   
         TAILQ_INIT(&(rdp->rd_branches));          TAILQ_INIT(&(rdp->rd_branches));
Line 1479 
Line 1417 
         if (username == NULL)          if (username == NULL)
                 username = pw->pw_name;                  username = pw->pw_name;
   
         if ((rdp->rd_author = strdup(username)) == NULL) {          rdp->rd_author = xstrdup(username);
                 rcs_freedelta(rdp);          rdp->rd_state = xstrdup(RCS_STATE_EXP);
                 rcsnum_free(old);          rdp->rd_log = xstrdup(msg);
                 return (-1);  
         }  
   
         if ((rdp->rd_state = strdup(RCS_STATE_EXP)) == NULL) {  
                 rcs_freedelta(rdp);  
                 rcsnum_free(old);  
                 return (-1);  
         }  
   
         if ((rdp->rd_log = strdup(msg)) == NULL) {  
                 rcs_errno = RCS_ERR_ERRNO;  
                 rcs_freedelta(rdp);  
                 rcsnum_free(old);  
                 return (-1);  
         }  
   
         if (date != (time_t)(-1))          if (date != (time_t)(-1))
                 now = date;                  now = date;
         else          else
Line 1608 
Line 1531 
                         buf[i++] = 'l';                          buf[i++] = 'l';
         }          }
   
         if ((tmp = strdup(buf)) == NULL) {          tmp = xstrdup(buf);
                 cvs_log(LP_ERRNO, "%s: failed to copy expansion mode",  
                     file->rf_path);  
                 return (-1);  
         }  
   
         if (file->rf_expand != NULL)          if (file->rf_expand != NULL)
                 free(file->rf_expand);                  free(file->rf_expand);
         file->rf_expand = tmp;          file->rf_expand = tmp;
Line 1719 
Line 1637 
         if (rfp->rf_flags & RCS_PARSED)          if (rfp->rf_flags & RCS_PARSED)
                 return (0);                  return (0);
   
         if ((pdp = (struct rcs_pdata *)malloc(sizeof(*pdp))) == NULL) {          pdp = (struct rcs_pdata *)xmalloc(sizeof(*pdp));
                 rcs_errno = RCS_ERR_ERRNO;  
                 cvs_log(LP_ERRNO, "failed to allocate RCS parser data");  
                 return (-1);  
         }  
         memset(pdp, 0, sizeof(*pdp));          memset(pdp, 0, sizeof(*pdp));
   
         pdp->rp_lines = 0;          pdp->rp_lines = 0;
Line 1737 
Line 1651 
                 return (-1);                  return (-1);
         }          }
   
         pdp->rp_buf = (char *)malloc((size_t)RCS_BUFSIZE);          pdp->rp_buf = (char *)xmalloc((size_t)RCS_BUFSIZE);
         if (pdp->rp_buf == NULL) {  
                 rcs_errno = RCS_ERR_ERRNO;  
                 cvs_log(LP_ERRNO, "failed to allocate RCS parser buffer");  
                 rcs_freepdata(pdp);  
                 return (-1);  
         }  
         pdp->rp_blen = RCS_BUFSIZE;          pdp->rp_blen = RCS_BUFSIZE;
         pdp->rp_bufend = pdp->rp_buf + pdp->rp_blen - 1;          pdp->rp_bufend = pdp->rp_buf + pdp->rp_blen - 1;
   
Line 1784 
Line 1692 
                 return (-1);                  return (-1);
         }          }
   
         rfp->rf_desc = strdup(RCS_TOKSTR(rfp));          rfp->rf_desc = xstrdup(RCS_TOKSTR(rfp));
         if (rfp->rf_desc == NULL) {  
                 cvs_log(LP_ERRNO, "failed to duplicate rcs token");  
                 rcs_freepdata(pdp);  
                 return (-1);  
         }  
   
         for (;;) {          for (;;) {
                 ret = rcs_parse_deltatext(rfp);                  ret = rcs_parse_deltatext(rfp);
                 if (ret == 0)                  if (ret == 0)
Line 1886 
Line 1788 
                                     rfp->rf_branch) < 0)                                      rfp->rf_branch) < 0)
                                         return (-1);                                          return (-1);
                         } else if (tok == RCS_TOK_COMMENT) {                          } else if (tok == RCS_TOK_COMMENT) {
                                 rfp->rf_comment = strdup(RCS_TOKSTR(rfp));                                  rfp->rf_comment = xstrdup(RCS_TOKSTR(rfp));
                                 if (rfp->rf_comment == NULL) {  
                                         cvs_log(LP_ERRNO,  
                                             "failed to duplicate rcs token");  
                                         return (-1);  
                                 }  
                         } else if (tok == RCS_TOK_EXPAND) {                          } else if (tok == RCS_TOK_EXPAND) {
                                 rfp->rf_expand = strdup(RCS_TOKSTR(rfp));                                  rfp->rf_expand = xstrdup(RCS_TOKSTR(rfp));
                                 if (rfp->rf_expand == NULL) {  
                                         cvs_log(LP_ERRNO,  
                                             "failed to duplicate rcs token");  
                                         return (-1);  
                                 }  
                         }                          }
   
                         /* now get the expected semi-colon */                          /* now get the expected semi-colon */
Line 1953 
Line 1845 
         struct rcs_delta *rdp;          struct rcs_delta *rdp;
         struct rcs_key *rk;          struct rcs_key *rk;
   
         rdp = (struct rcs_delta *)malloc(sizeof(*rdp));          rdp = (struct rcs_delta *)xmalloc(sizeof(*rdp));
         if (rdp == NULL) {  
                 rcs_errno = RCS_ERR_ERRNO;  
                 cvs_log(LP_ERRNO, "failed to allocate RCS delta structure");  
                 return (-1);  
         }  
         memset(rdp, 0, sizeof(*rdp));          memset(rdp, 0, sizeof(*rdp));
   
         rdp->rd_num = rcsnum_alloc();          rdp->rd_num = rcsnum_alloc();
Line 2044 
Line 1931 
                         }                          }
   
                         if (tokstr != NULL)                          if (tokstr != NULL)
                                 free(tokstr);                                  xfree(tokstr);
                         tokstr = strdup(RCS_TOKSTR(rfp));                          tokstr = xstrdup(RCS_TOKSTR(rfp));
                         if (tokstr == NULL) {  
                                 cvs_log(LP_ERRNO,  
                                     "failed to duplicate rcs token");  
                                 rcs_freedelta(rdp);  
                                 return (-1);  
                         }  
   
                         /* now get the expected semi-colon */                          /* now get the expected semi-colon */
                         ntok = rcs_gettok(rfp);                          ntok = rcs_gettok(rfp);
                         if (ntok != RCS_TOK_SCOLON) {                          if (ntok != RCS_TOK_SCOLON) {
Line 2060 
Line 1940 
                                 cvs_log(LP_ERR,                                  cvs_log(LP_ERR,
                                     "missing semi-colon after RCS `%s' key",                                      "missing semi-colon after RCS `%s' key",
                                     rk->rk_str);                                      rk->rk_str);
                                 free(tokstr);                                  xfree(tokstr);
                                 rcs_freedelta(rdp);                                  rcs_freedelta(rdp);
                                 return (-1);                                  return (-1);
                         }                          }
   
                         if (tok == RCS_TOK_DATE) {                          if (tok == RCS_TOK_DATE) {
                                 if ((datenum = rcsnum_parse(tokstr)) == NULL) {                                  if ((datenum = rcsnum_parse(tokstr)) == NULL) {
                                         free(tokstr);                                          xfree(tokstr);
                                         rcs_freedelta(rdp);                                          rcs_freedelta(rdp);
                                         return (-1);                                          return (-1);
                                 }                                  }
Line 2078 
Line 1958 
                                             "fields",                                              "fields",
                                             (datenum->rn_len > 6) ? "too many" :                                              (datenum->rn_len > 6) ? "too many" :
                                             "missing");                                              "missing");
                                         free(tokstr);                                          xfree(tokstr);
                                         rcs_freedelta(rdp);                                          rcs_freedelta(rdp);
                                         rcsnum_free(datenum);                                          rcsnum_free(datenum);
                                         return (-1);                                          return (-1);
Line 2119 
Line 1999 
         }          }
   
         if (tokstr != NULL)          if (tokstr != NULL)
                 free(tokstr);                  xfree(tokstr);
   
         TAILQ_INSERT_TAIL(&(rfp->rf_delta), rdp, rd_list);          TAILQ_INSERT_TAIL(&(rfp->rf_delta), rdp, rd_list);
         rfp->rf_ndelta++;          rfp->rf_ndelta++;
Line 2186 
Line 2066 
                     RCS_TOKSTR(rfp));                      RCS_TOKSTR(rfp));
                 return (-1);                  return (-1);
         }          }
         rdp->rd_log = strdup(RCS_TOKSTR(rfp));          rdp->rd_log = xstrdup(RCS_TOKSTR(rfp));
         if (rdp->rd_log == NULL) {  
                 cvs_log(LP_ERRNO, "failed to copy RCS deltatext log");  
                 return (-1);  
         }  
   
         tok = rcs_gettok(rfp);          tok = rcs_gettok(rfp);
         if (tok != RCS_TOK_TEXT) {          if (tok != RCS_TOK_TEXT) {
                 rcs_errno = RCS_ERR_PARSE;                  rcs_errno = RCS_ERR_PARSE;
Line 2208 
Line 2083 
                 return (-1);                  return (-1);
         }          }
   
         rdp->rd_text = (u_char *)malloc(RCS_TOKLEN(rfp) + 1);          rdp->rd_text = (u_char *)xmalloc(RCS_TOKLEN(rfp) + 1);
         if (rdp->rd_text == NULL) {  
                 cvs_log(LP_ERRNO, "failed to copy RCS delta text");  
                 return (-1);  
         }  
         strlcpy(rdp->rd_text, RCS_TOKSTR(rfp), (RCS_TOKLEN(rfp) + 1));          strlcpy(rdp->rd_text, RCS_TOKSTR(rfp), (RCS_TOKLEN(rfp) + 1));
         rdp->rd_tlen = RCS_TOKLEN(rfp);          rdp->rd_tlen = RCS_TOKLEN(rfp);
   
Line 2269 
Line 2140 
                         return (-1);                          return (-1);
                 }                  }
   
                 symp = (struct rcs_sym *)malloc(sizeof(*symp));                  symp = (struct rcs_sym *)xmalloc(sizeof(*symp));
                 if (symp == NULL) {                  symp->rs_name = xstrdup(RCS_TOKSTR(rfp));
                         rcs_errno = RCS_ERR_ERRNO;  
                         cvs_log(LP_ERRNO, "failed to allocate RCS symbol");  
                         return (-1);  
                 }  
                 symp->rs_name = strdup(RCS_TOKSTR(rfp));  
                 if (symp->rs_name == NULL) {  
                         cvs_log(LP_ERRNO, "failed to duplicate rcs token");  
                         free(symp);  
                         return (-1);  
                 }  
   
                 symp->rs_num = rcsnum_alloc();                  symp->rs_num = rcsnum_alloc();
                 if (symp->rs_num == NULL) {                  if (symp->rs_num == NULL) {
                         cvs_log(LP_ERRNO, "failed to allocate rcsnum info");                          cvs_log(LP_ERRNO, "failed to allocate rcsnum info");
                         free(symp->rs_name);                          xfree(symp->rs_name);
                         free(symp);                          xfree(symp);
                         return (-1);                          return (-1);
                 }                  }
   
Line 2296 
Line 2156 
                         cvs_log(LP_ERR, "unexpected token `%s' in symbol list",                          cvs_log(LP_ERR, "unexpected token `%s' in symbol list",
                             RCS_TOKSTR(rfp));                              RCS_TOKSTR(rfp));
                         rcsnum_free(symp->rs_num);                          rcsnum_free(symp->rs_num);
                         free(symp->rs_name);                          xfree(symp->rs_name);
                         free(symp);                          xfree(symp);
                         return (-1);                          return (-1);
                 }                  }
   
Line 2307 
Line 2167 
                         cvs_log(LP_ERR, "unexpected token `%s' in symbol list",                          cvs_log(LP_ERR, "unexpected token `%s' in symbol list",
                             RCS_TOKSTR(rfp));                              RCS_TOKSTR(rfp));
                         rcsnum_free(symp->rs_num);                          rcsnum_free(symp->rs_num);
                         free(symp->rs_name);                          xfree(symp->rs_name);
                         free(symp);                          xfree(symp);
                         return (-1);                          return (-1);
                 }                  }
   
Line 2316 
Line 2176 
                         cvs_log(LP_ERR, "failed to parse RCS NUM `%s'",                          cvs_log(LP_ERR, "failed to parse RCS NUM `%s'",
                             RCS_TOKSTR(rfp));                              RCS_TOKSTR(rfp));
                         rcsnum_free(symp->rs_num);                          rcsnum_free(symp->rs_num);
                         free(symp->rs_name);                          xfree(symp->rs_name);
                         free(symp);                          xfree(symp);
                         return (-1);                          return (-1);
                 }                  }
   
Line 2351 
Line 2211 
                         return (-1);                          return (-1);
                 }                  }
   
                 lkp = (struct rcs_lock *)malloc(sizeof(*lkp));                  lkp = (struct rcs_lock *)xmalloc(sizeof(*lkp));
                 if (lkp == NULL) {                  lkp->rl_name = xstrdup(RCS_TOKSTR(rfp));
                         cvs_log(LP_ERRNO, "failed to allocate RCS lock");  
                         return (-1);  
                 }  
   
                 if ((lkp->rl_name = strdup(RCS_TOKSTR(rfp))) == NULL) {  
                         cvs_log(LP_ERR, "failed to save locking user");  
                         free(lkp);  
                         return (-1);  
                 }  
   
                 lkp->rl_num = rcsnum_alloc();                  lkp->rl_num = rcsnum_alloc();
                 if (lkp->rl_num == NULL) {                  if (lkp->rl_num == NULL) {
                         free(lkp->rl_name);                          xfree(lkp->rl_name);
                         free(lkp);                          xfree(lkp);
                         return (-1);                          return (-1);
                 }                  }
   
Line 2376 
Line 2226 
                         cvs_log(LP_ERR, "unexpected token `%s' in symbol list",                          cvs_log(LP_ERR, "unexpected token `%s' in symbol list",
                             RCS_TOKSTR(rfp));                              RCS_TOKSTR(rfp));
                         rcsnum_free(lkp->rl_num);                          rcsnum_free(lkp->rl_num);
                         free(lkp->rl_name);                          xfree(lkp->rl_name);
                         free(lkp);                          xfree(lkp);
                         return (-1);                          return (-1);
                 }                  }
   
Line 2387 
Line 2237 
                         cvs_log(LP_ERR, "unexpected token `%s' in symbol list",                          cvs_log(LP_ERR, "unexpected token `%s' in symbol list",
                             RCS_TOKSTR(rfp));                              RCS_TOKSTR(rfp));
                         rcsnum_free(lkp->rl_num);                          rcsnum_free(lkp->rl_num);
                         free(lkp->rl_name);                          xfree(lkp->rl_name);
                         free(lkp);                          xfree(lkp);
                         return (-1);                          return (-1);
                 }                  }
   
Line 2396 
Line 2246 
                         cvs_log(LP_ERR, "failed to parse RCS NUM `%s'",                          cvs_log(LP_ERR, "failed to parse RCS NUM `%s'",
                             RCS_TOKSTR(rfp));                              RCS_TOKSTR(rfp));
                         rcsnum_free(lkp->rl_num);                          rcsnum_free(lkp->rl_num);
                         free(lkp->rl_name);                          xfree(lkp->rl_name);
                         free(lkp);                          xfree(lkp);
                         return (-1);                          return (-1);
                 }                  }
   
Line 2448 
Line 2298 
                         return (-1);                          return (-1);
                 }                  }
   
                 brp = (struct rcs_branch *)malloc(sizeof(*brp));                  brp = (struct rcs_branch *)xmalloc(sizeof(*brp));
                 if (brp == NULL) {  
                         rcs_errno = RCS_ERR_ERRNO;  
                         cvs_log(LP_ERRNO, "failed to allocate RCS branch");  
                         return (-1);  
                 }  
                 brp->rb_num = rcsnum_parse(RCS_TOKSTR(rfp));                  brp->rb_num = rcsnum_parse(RCS_TOKSTR(rfp));
                 if (brp->rb_num == NULL) {                  if (brp->rb_num == NULL) {
                         free(brp);                          xfree(brp);
                         return (-1);                          return (-1);
                 }                  }
   
Line 2483 
Line 2328 
                 rcsnum_free(rdp->rd_next);                  rcsnum_free(rdp->rd_next);
   
         if (rdp->rd_author != NULL)          if (rdp->rd_author != NULL)
                 free(rdp->rd_author);                  xfree(rdp->rd_author);
         if (rdp->rd_locker != NULL)          if (rdp->rd_locker != NULL)
                 free(rdp->rd_locker);                  xfree(rdp->rd_locker);
         if (rdp->rd_state != NULL)          if (rdp->rd_state != NULL)
                 free(rdp->rd_state);                  xfree(rdp->rd_state);
         if (rdp->rd_log != NULL)          if (rdp->rd_log != NULL)
                 free(rdp->rd_log);                  xfree(rdp->rd_log);
         if (rdp->rd_text != NULL)          if (rdp->rd_text != NULL)
                 free(rdp->rd_text);                  xfree(rdp->rd_text);
   
         while ((rb = TAILQ_FIRST(&(rdp->rd_branches))) != NULL) {          while ((rb = TAILQ_FIRST(&(rdp->rd_branches))) != NULL) {
                 TAILQ_REMOVE(&(rdp->rd_branches), rb, rb_list);                  TAILQ_REMOVE(&(rdp->rd_branches), rb, rb_list);
                 rcsnum_free(rb->rb_num);                  rcsnum_free(rb->rb_num);
                 free(rb);                  xfree(rb);
         }          }
   
         while ((crdp = TAILQ_FIRST(&(rdp->rd_snodes))) != NULL) {          while ((crdp = TAILQ_FIRST(&(rdp->rd_snodes))) != NULL) {
Line 2504 
Line 2349 
                 rcs_freedelta(crdp);                  rcs_freedelta(crdp);
         }          }
   
         free(rdp);          xfree(rdp);
 }  }
   
 /*  /*
Line 2518 
Line 2363 
         if (pd->rp_file != NULL)          if (pd->rp_file != NULL)
                 (void)fclose(pd->rp_file);                  (void)fclose(pd->rp_file);
         if (pd->rp_buf != NULL)          if (pd->rp_buf != NULL)
                 free(pd->rp_buf);                  xfree(pd->rp_buf);
         free(pd);          xfree(pd);
 }  }
   
 /*  /*
Line 2901 
Line 2746 
                 return (-1);                  return (-1);
   
         if (rdp->rd_text != NULL)          if (rdp->rd_text != NULL)
                 free(rdp->rd_text);                  xfree(rdp->rd_text);
   
         len = strlen(dtext);          len = strlen(dtext);
         if (len != 0) {          if (len != 0) {
                 if ((rdp->rd_text = (u_char *)malloc(len)) == NULL)                  rdp->rd_text = (u_char *)xmalloc(len);
                         return (-1);  
   
                 rdp->rd_tlen = len - 1;                  rdp->rd_tlen = len - 1;
                 strlcpy(rdp->rd_text, dtext, len);                  strlcpy(rdp->rd_text, dtext, len);
         } else {          } else {
Line 2935 
Line 2778 
                 return (-1);                  return (-1);
   
         if (rdp->rd_log != NULL)          if (rdp->rd_log != NULL)
                 free(rdp->rd_log);                  xfree(rdp->rd_log);
   
         if ((rdp->rd_log = strdup(logtext)) == NULL)          rdp->rd_log = xstrdup(logtext);
                 return (-1);  
   
         rfp->rf_flags &= ~RCS_SYNCED;          rfp->rf_flags &= ~RCS_SYNCED;
         return (0);          return (0);
 }  }
Line 2977 
Line 2818 
                 return (-1);                  return (-1);
   
         if (rdp->rd_state != NULL)          if (rdp->rd_state != NULL)
                 free(rdp->rd_state);                  xfree(rdp->rd_state);
   
         if ((rdp->rd_state = strdup(state)) == NULL)          rdp->rd_state = xstrdup(state);
                 return (-1);  
   
         rfp->rf_flags &= ~RCS_SYNCED;          rfp->rf_flags &= ~RCS_SYNCED;
   
Line 3253 
Line 3093 
         if (bp != NULL)          if (bp != NULL)
                 cvs_buf_free(bp);                  cvs_buf_free(bp);
         if (content != NULL)          if (content != NULL)
                 free(content);                  xfree(content);
   
         return (ret);          return (ret);
 }  }
Legend:
Removed from v.1.109  
changed lines
  Added in v.1.110