| blob | 8921e395e0e79eeda0448503be8df65e37b7808a |
1 /* cvsclone.l */
3 /*
4 * Copyright (C) 2006 Peter Backes <rtc@gmx.de>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * BUILDING
21 *
22 * flex cvsclone.l && gcc -Wall -O2 lex.yy.c -o cvsclone
23 *
24 * EXAMPLE
25 *
26 * *-------------------------------------------------------------------*
27 * | Applying this tool to sourceforge.net or savannah.gnu.org is |
28 * | neither necessary nor recommended: With $1 being the project, you |
29 * | can simply |
30 * | rsync -av rsync://$1.cvs.sourceforge.net/cvsroot/$1/ $1 |
31 * | or |
32 * | rsync -av rsync://cvs.sv.gnu.org/sources/$1 $1 |
33 * | respectively (try also 'web' instead of 'sources'). |
34 * *-------------------------------------------------------------------*
35 *
36 * cvsclone -d :pserver:anonymous@cvs.example.org:/var/lib/cvs module
37 *
38 * DESCRIPTION
39 *
40 * Utility to clone cvs repositories over the cvspserver interface. Works
41 * for anonymous access.
42 *
43 * FEATURES
44 *
45 * - reads $HOME/.cvspass
46 *
47 * - can clone corrupt repositories: writes ,v files directly, does not
48 * need rcs. (For example, ccvs module has archives that go backwards
49 * in time.)
50 *
51 * PROBLEMS
52 *
53 * - can't enable compression.
54 *
55 * - reading cvs password from $HOME/.cvspass uses CVSROOT in a
56 * case sensitive way.
57 *
58 * - rlog format is ambiguous. If the separators it uses are found inside
59 * log messages, possibly followed by lines similar to what rlog
60 * outputs, things can go wrong horribly.
61 *
62 * - rcs 5.x rlog format does not contain the comment leader. It is
63 * guessed according to the extension as rcs and CVS do.
64 *
65 * - uses normal diff format since this is the easiest one that works.
66 * diff --rcs is problematic, since files without newline at the
67 * last line are not output correctly. The major drawback about this
68 * is that deleted lines are transfered while they don't need to be.
69 * even rdiff has major problems with lines that contain \0, because
70 * of a bug in cvs.
71 *
72 * - does not work incrementally. That would be much more work if
73 * updating the trunk since the most recent revision had to be
74 * reconstructed. Also, the whole history probably had to be transfered
75 * again, with all log messages.
76 *
77 * - Horrible complexity. A file with n deltas takes O(n^2) to transfer.
78 *
79 * - Makes the cvs server really work hard, taking up all processor time.
80 * It should really not be used on public cvs servers, especially
81 * not on a regular basis. Perhaps it is useful for salvaging
82 * archive files from projects where only access to anonymous cvs
83 * is available.
84 *
85 *
86 * Patches and comments are welcome.
87 *
88 */
89 %{
90 #include <sys/stat.h>
91 #include <sys/types.h>
92 #include <sys/socket.h>
93 #include <netdb.h>
94 #include <resolv.h>
95 #include <unistd.h>
96 #include <fcntl.h>
97 #include <signal.h>
99 #include <errno.h>
100 #include <ctype.h>
101 #include <assert.h>
102 #include <stdlib.h>
103 #include <time.h>
104 #include <stdio.h>
105 #include <string.h>
106 #ifdef _IO_getc_unlocked
107 #undef getc
108 #define getc _IO_getc_unlocked
109 #endif
110 %}
111 %s HDR0 HDR1 DESC ACCL0 TAGL0 TAGL1 LCKL0 LCKL1 REV0 REV1 REV2 ATR0 ATR1
112 %s REV3 REV4 RLST XREV FEND SRV0 SRVA SRVB SRV1 SRV2 SRV3 SRV4 SRV5 SRV6 PWF0
113 %s REVSKIP
114 %option noyywrap nounput
115 num [0-9.]+
116 special [$,.:;@]
117 idchar [^$,.:;@ \b\t\v\f\r\n]
118 ws [ \b\t\v\f\r]
119 id {num}?{idchar}({idchar}|{num})*
120 sym [0-9]?{idchar}({idchar}|[0-9])*
121 xid ({idchar}|{special}|{ws})+
122 yid ({idchar}|{special})+
123 nws (ws|\n)
124 date1 [0-9]+(-[0-9]{2}){2}\ [0-9]{2}(:[0-9]{2}){2}\ [-+][0-9]{4}
125 date2 [0-9]+(\/[0-9]{2}){2}\ [0-9]{2}(:[0-9]{2}){2}
127 /*
128 RCS file: x,v
129 Working file: x
130 head: 1.2
131 branch: 1.1
132 locks: [strict]
133 rtc: 1.1
134 rtc: 1.1.2.1
135 access list:
136 root
137 rtc
138 symbolic names:
139 test: 1.1
140 keyword substitution: kv
141 total revisions: ; selected\ revisions:
142 description:
145 file() : trunk(Head) tree(Head)
146 ;
147 trunk(p) :
148 | adelta(p) trunk(p->next)
149 ;
150 tree(root) :
151 | tree(root->next) forest(root->branches)
152 ;
153 forest(broot) :
154 | forest(broot->nextbranch) abranch(broot) tree(broot)
155 ;
156 abranch(root) :
157 | abranch(root->next) adelta(root)
158 ;
160 adelta :
161 "----------------------------\n"
162 "revision %s" [ "\tlocked by: %s;" ] "\n"
164 "date: %s; author: %s; state: %s; lines: +%ld -%ld"
165 [ "; kopt: %s" ]
166 [ "; commitid: %s" ]
167 [ "; filename: %s" ]
168 [ "; mergepoint:" (" %s;")+ ]
169 "\n"
171 [ "branches:" (" %s;")+ "\n" ]
172 [ "included:" (" %s;")+ ]
173 [ "excluded:" (" %s;")+ ]
174 [ "ignored:" (" %s;")+ ] "\n" // '\n' if one of them is there
175 [ "source: %s" [ "\t%s" ] "\n" ]
177 <log>*"\n"
178 */
179 %{
180 char *getstr(unsigned long n, char *s)
181 {
182 s[n] = '\0';
183 return s;
184 }
185 union revref;
186 struct rev {
187 char *num;
188 time_t date;
189 char *author, *state, *comment, *commitid, *kopt;
190 int ladd, ldel;
191 /* mergepoint */
192 /* branches */
193 /* included */
194 /* excluded */
195 /* ignored */
196 char *server, /* originating server */
197 *onum; /* original number */
198 char *log;
199 struct rev *next, *branch, *sub;
200 };
201 union revref {
202 char *num;
203 struct rev *r;
204 };
205 struct rpair {
206 char *item;
207 union revref rev;
208 };
209 struct rcsfile {
210 char *source, *workfile;
211 union revref head, branch;
212 int strict;
213 char *ksub, *leader;
214 int tot, sel;
215 char *descr;
216 struct rpair *lckl, *lckt, *tagl, *tagt;
217 char **accl, **acct; /* access list, access top */
218 struct rev *revl, *revt;
219 } rfile;
221 void rcsinit(void)
222 {
223 rfile.source = rfile.workfile = rfile.head.num
224 = rfile.branch.num = rfile.ksub = rfile.leader
225 = rfile.descr = NULL;
226 rfile.strict = rfile.tot = rfile.sel = 0;
227 rfile.lckl = rfile.lckt = rfile.tagl = rfile.tagt = NULL;
228 rfile.revl = rfile.revt = NULL;
229 rfile.accl = rfile.acct = NULL;
230 }
232 void addaccl(char *s)
233 {
234 if (!rfile.accl)
235 rfile.acct = rfile.accl = malloc(16 * sizeof *rfile.accl);
236 else if (!((rfile.acct - rfile.accl) % 16)) {
237 unsigned long n = rfile.acct - rfile.accl;
238 rfile.accl = realloc(rfile.accl, (n+16) * sizeof *rfile.accl);
239 rfile.acct = rfile.accl + n;
240 }
242 *rfile.acct++ = s;
243 }
244 void addtag(char *s)
245 {
246 if (!rfile.tagl)
247 rfile.tagt = rfile.tagl = malloc(16 * sizeof *rfile.tagl);
248 else if (!((rfile.tagt - rfile.tagl) % 16)) {
249 unsigned long n = rfile.tagt - rfile.tagl;
250 rfile.tagl = realloc(rfile.tagl, (n+16) * sizeof *rfile.tagl);
251 rfile.tagt = rfile.tagl + n;
252 }
254 rfile.tagt++->item = s;
255 }
256 void addlck(char *s)
257 {
258 if (!rfile.lckl)
259 rfile.lckt = rfile.lckl = malloc(16 * sizeof *rfile.lckl);
260 else if (!((rfile.lckt - rfile.lckl) % 16)) {
261 unsigned long n = rfile.lckt - rfile.lckl;
262 rfile.lckl = realloc(rfile.lckl, (n+16) * sizeof *rfile.lckl);
263 rfile.lckt = rfile.lckl + n;
264 }
266 rfile.lckt++->item = s;
267 }
268 void setdate(unsigned long n, char *s, char *t)
269 {
270 char d;
271 struct tm tm;
272 sscanf(s, "%d%c%d%c%d %d:%d:%d", &tm.tm_year, &d, &tm.tm_mon, &d,
273 &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
274 tm.tm_year -= 1900;
275 tm.tm_mon--;
276 if (t) {
277 int z = atoi(t);
278 if (z < 0)
279 tm.tm_sec += -z / 100 * 3600 + -z % 100 * 60;
280 else
281 tm.tm_sec -= z / 100 * 3600 + z % 100 * 60;
282 }
283 rfile.revt->date = timegm(&tm);
284 #if 0
285 printf("setdate: %.*s, %.5s --> %s", (int)n, s, t,
286 ctime(&rfile.revt->date));
287 #endif
289 }
290 void addrev(char *s)
291 {
292 if (!rfile.revt)
293 rfile.revt = rfile.revl;
294 else
295 rfile.revt++;
296 assert(rfile.revl && rfile.revt < rfile.revl + rfile.sel);
297 /* assert(rfile.revt - rfile.revl < rfile.n) */
298 rfile.revt->num = s;
299 rfile.revt->author = rfile.revt->state
300 = rfile.revt->comment = rfile.revt->commitid
301 = rfile.revt->kopt = rfile.revt->server
302 = rfile.revt->onum = rfile.revt->log = NULL;
303 rfile.revt->next = rfile.revt->branch = rfile.revt->sub = NULL;
304 rfile.revt->ladd = rfile.revt->ldel = 0;
305 }
306 void addrl(char *s)
307 {
308 }
309 void initrev(int n)
310 {
311 if ((rfile.sel = n))
312 rfile.revl = malloc(n * sizeof *rfile.revl);
313 }
314 char *cvsroot, *cvspass, *cvsuser, *cvshost, *cvsdir;
315 int chkroot(char *s, size_t le, int s1)
316 {
317 size_t l = strlen(cvsroot);
319 if (s1) {
320 char *x, *y;
321 #if 0
322 fprintf(stderr, "cvsroot=%s, s=%s, s1=%d\n", cvsroot, s, s1);
323 #endif
324 if (*s != ':' || !(x = strchr(s + 1, ':'))
325 || !(x = strchr(x + 1, ':'))
326 || strncmp(cvsroot, s, x - s + 1)
327 || !isdigit(*(x + 1)))
328 return 0;
329 #if 0
330 fprintf(stderr, "survived\n");
331 #endif
332 y = cvsroot + (x - s) + 1;
333 while (isdigit(*++x))
334 continue;
335 if (strncmp(y, x, l - (y - cvsroot))
336 || x[l - (y - cvsroot)] != ' ')
337 return 0;
338 l += x - s - (y - cvsroot);
339 #if 0
340 fprintf(stderr, "l=%u(%d, %u), s=%s, cvsroot=%s, x=%s, y=%s\n",
341 l, x - s - (y - cvsroot), le,
342 s, cvsroot, x, y);
343 #endif
344 } else if (strncmp(cvsroot, s, l) || s[l] != ' ')
345 return 0;
347 cvsroot = strncpy(realloc(cvsroot, le + 1), s, le);
348 cvsroot[l] = cvsroot[le+1] = '\0';
349 cvspass = cvsroot + l + 1;
350 return 1;
351 }
352 FILE *rcsfiop;
353 void rcsfwrite(char *s, size_t l, FILE *stream)
354 {
355 for (; l--; putc(*s++, stream))
356 if (*s == '@')
357 putc(*s, stream);
358 }
359 void rcsrang(int d0, int d1, int a0, int a1)
360 {
361 fprintf(rcsfiop, "d%d %d\na%d %d\n", d0, d1-d0+1, d1, a1-a0+1);
362 }
363 void rcsrang2(int d0, int d1, int a)
364 {
365 fprintf(rcsfiop, "d%d %d\n", d0, d1-d0+1);
366 }
367 void rcsrang3(int d, int a0, int a1)
368 {
369 fprintf(rcsfiop, "a%d %d\n", d, a1-a0+1);
370 }
371 char *queue, *que;
372 size_t queuel;
373 char *getq(size_t l)
374 {
375 if (!queue)
376 return queue = malloc(queuel = l);
377 queuel += l;
378 queue = realloc(queue, queuel);
379 return queue + queuel - l;
380 }
381 void begin(char *s, size_t l)
382 {
383 char *p = s + 10, *fi, *fi2;
384 size_t l0 = strlen(cvsdir);
385 s[l-1] = '\0';
386 if (strncmp(cvsdir, p, l0) || p[l0] != '/') {
387 fprintf(stderr, "path mismatch.\n");
388 return;
389 }
390 fi = p + l0 + 1;
391 while ((fi2 = strchr(fi, '/'))) {
392 *fi2 = '\0';
393 mkdir(p + l0 + 1, 0777);
394 *fi2 = '/';
395 fi = fi2 + 1;
396 }
397 strcpy(getq(strlen(p + l0 + 1) + 1), p + l0 + 1);
398 if (!access(p + l0 + 1, R_OK)) {
399 char buffer[1024];
400 snprintf(buffer, sizeof(buffer), "%s.old", p + l0 + 1);
401 rename(p + l0 + 1, buffer);
402 }
403 if (!(rcsfiop = fopen(p + l0 + 1, "w")))
404 return;
405 s[l-1] = '\n';
406 fputs("\n", rcsfiop);
407 fwrite(s, 1, l, rcsfiop);
408 }
410 %}
412 %%
413 <HDR0>RCS\ file:\ {xid}\n rfile.source = getstr(yyleng-11, yytext+10);
414 <HDR0>Working\ file:\ {xid}\n rfile.workfile = getstr(yyleng-15, yytext+14);
415 <HDR0>head:\ {num}\n rfile.head.num = getstr(yyleng-7, yytext+6);
416 <HDR0>head:\n rfile.head.num = NULL;
417 <HDR0>branch:\n rfile.branch.num = NULL;
418 <HDR0>branch:\ {num}\n rfile.branch.num = getstr(yyleng-9, yytext+8);
419 <HDR0>locks:\ strict\n BEGIN LCKL0; rfile.strict = 1;
420 <HDR0>locks:\n BEGIN LCKL0; rfile.strict = 0;
421 <HDR0>access\ list:\n BEGIN ACCL0;
422 <HDR0>symbolic\ names:\n BEGIN TAGL0;
423 <HDR0>keyword\ substitution:\ .*\n rfile.ksub = getstr(yyleng-23, yytext+22);
424 <HDR0>comment\ leader:\ \".*\"\n rfile.leader = getstr(yyleng-19, yytext+17);
425 <HDR0>total\ revisions:\ [0-9]+;\t BEGIN HDR1; rfile.tot = atoi(yytext+17);
426 <HDR1>selected\ revisions:\ [0-9]+\n BEGIN HDR0; initrev(atoi(yytext+20));
427 <HDR0>description:\n BEGIN DESC;
428 <HDR0>\n /* EMPTY */
429 <DESC>={77}\n BEGIN FEND; *yytext = '\0'; if (!rfile.descr) rfile.descr = yytext;
430 <DESC>-{28}\n BEGIN REV0; *yytext = '\0'; if (!rfile.descr) rfile.descr = yytext;
431 <DESC>.*\n if (!rfile.descr) rfile.descr = yytext;
432 <ACCL0>\t{id}\n addaccl(getstr(yyleng-2, yytext+1));
433 <ACCL0>""/[^\t] BEGIN HDR0;
434 <TAGL0>\t{sym}:\ BEGIN TAGL1; addtag(getstr(yyleng-3, yytext+1));
435 <TAGL0>""/[^\t] BEGIN HDR0;
436 <TAGL1>{num}\n BEGIN TAGL0; rfile.tagt[-1].rev.num = getstr(yyleng-1, yytext);
437 <LCKL0>\t{id}:\ BEGIN LCKL1; addlck(getstr(yyleng-3, yytext+1));
438 <LCKL0>""/[^\t] BEGIN HDR0;
439 <LCKL1>{num}\n BEGIN LCKL0; rfile.lckt[-1].rev.num = getstr(yyleng-1, yytext);
440 <REV0>revision\ {num}\n BEGIN REV2; addrev(getstr(yyleng-10, yytext+9));
441 <REV0>revision\ {num}\t BEGIN REV1; addrev(getstr(yyleng-10, yytext+9));
442 <REV1>locked\ by:\ {id};\n BEGIN REV2; /* getstr(yyleng-13, yytext+11); */
443 <REV2>date:\ {date1};\ \ BEGIN ATR0; setdate(yyleng-15, yytext+6, yytext+yyleng-8);
444 <REV2>date:\ {date2};\ \ BEGIN ATR0; setdate(yyleng-9, yytext+6, NULL);
445 <ATR0>author:\ {id};\ \ rfile.revt->author = getstr(yyleng-11, yytext+8);
446 <ATR0>state:\ {id};\ \ rfile.revt->state = getstr(yyleng-10, yytext+7);
447 <ATR0>state:\ {id};\n BEGIN REV3; rfile.revt->state = getstr(yyleng-9, yytext+7);
448 <ATR0>lines:\ \+[0-9]+\ BEGIN ATR1; rfile.revt->ladd = atoi(yytext+8);
449 <ATR1>-[0-9]+;?\n BEGIN REV3; rfile.revt->ldel = atoi(yytext+1);
450 <ATR1>-[0-9]+;\ \ BEGIN ATR0; rfile.revt->ldel = atoi(yytext+1);
451 <ATR0>kopt:\ [^;\n]+;\n BEGIN REV3; rfile.revt->kopt = getstr(yyleng-8, yytext+6);
452 <ATR0>kopt:\ [^;\n]+;\ \ rfile.revt->kopt = getstr(yyleng-9, yytext+6);
453 <ATR0>commitid:\ [0-9a-zA-Z]{16};\ \ rfile.revt->commitid = getstr(16, yytext+10);
454 <ATR0>commitid:\ [0-9a-zA-Z]{16};\n BEGIN REV3; rfile.revt->commitid = getstr(16, yytext+10);
455 <ATR0>mergepoint:\ {num};\n BEGIN REV3; /* getstr(yyleng-14, yytext+12); */
456 <REV3>branches:/.*\n BEGIN RLST;
457 <REV3,REV4>={77}\n BEGIN FEND; *yytext = '\0'; if (!rfile.revt->log) rfile.revt->log = yytext; if (rfile.revt) rfile.revt++;
458 <REV3,REV4>-{28}\n BEGIN REV0; *yytext = '\0'; if (!rfile.revt->log) rfile.revt->log = yytext;
459 <REV3>.*\n BEGIN REV4; assert(!rfile.revt->log); rfile.revt->log = yytext;
460 <RLST>\ \ {num}; addrl(getstr(yyleng-3, yytext+2));
461 <RLST>\n BEGIN REV3;
462 <REV4>The\ changelog\ prior\ to\ shifting.*\n BEGIN REVSKIP; *yytext = '\0'; if (!rfile.revt->log) rfile.revt->log = yytext;
463 <REVSKIP>={77}\n BEGIN REV0; *yytext = '\0'; if (!rfile.revt->log) rfile.revt->log = yytext;
464 <REVSKIP>.*\n *yytext = '\0'; /* do nothing */
465 <REV4>.*\n if (!rfile.revt->log) rfile.revt->log = yytext;
466 <FEND><<EOF>> return EOF;
468 <SRV0>M\ \n BEGIN SRVA;
469 <SRVA>M\ RCS\ file:\ {xid}\n BEGIN SRVB; begin(yytext+2, yyleng-2);
470 <SRVB>M\ ={77}\n BEGIN SRV0; fwrite(yytext+2, 1, yyleng-2, rcsfiop); fclose(rcsfiop);
471 <SRVB>M\ .*\n fwrite(yytext+2, 1, yyleng-2, rcsfiop);
472 <SRV0,SRV1,SRV2,SRV3,SRV4,SRV5,SRV6>E\ .*\n fwrite(yytext+2, 1, yyleng-2, stderr);
473 <SRV0>I\ LOVE\ YOU\n fprintf(stderr, "%s", yytext);
474 <SRV0>error\ [^ \n]*\ .*\n return 1;
475 <SRV0>ok\n return 0;
476 <SRV0><<EOF>> return EOF;
477 <SRV1>M\ <\ .*\n BEGIN SRV2; rcsfwrite(yytext+4, yyleng-5, rcsfiop);
478 <SRV2>M\ <\ .*\n yytext[3] = '\n'; rcsfwrite(yytext+3, yyleng-4, rcsfiop);
479 <SRV2>M\ \\\ .*\n BEGIN SRV3;
480 <SRV2,SRV5>ok\n putc('\n', rcsfiop); return 0;
481 <SRV2,SRV5>error\ [^ \n]*\ .*\n putc('\n', rcsfiop); return 1;
482 <SRV3,SRV1,SRV4,SRV6>ok\n return 0;
483 <SRV3,SRV1,SRV4,SRV6>error\ [^ \n]*\ .*\n return 1;
484 <SRV4>M\ [0-9]+,[0-9]+c[0-9]+,[0-9]+\n rcsrang(atoi(yytext+2), atoi(strchr(yytext, ',')+1), atoi(strchr(yytext, 'c')+1), atoi(strrchr(yytext, ',')+1));
485 <SRV4>M\ [0-9]+c[0-9]+,[0-9]+\n rcsrang(atoi(yytext+2), atoi(yytext+2), atoi(strchr(yytext, 'c')+1), atoi(strrchr(yytext, ',')+1));
486 <SRV4>M\ [0-9]+,[0-9]+c[0-9]+\n rcsrang(atoi(yytext+2), atoi(strchr(yytext, ',')+1), atoi(strchr(yytext, 'c')+1), atoi(strchr(yytext, 'c')+1));
487 <SRV4>M\ [0-9]+c[0-9]+\n rcsrang(atoi(yytext+2), atoi(yytext+2), atoi(strchr(yytext, 'c')+1), atoi(strchr(yytext, 'c')+1));
488 <SRV4>M\ [0-9]+,[0-9]+d[0-9]+\n rcsrang2(atoi(yytext+2), atoi(strchr(yytext, ',')+1), atoi(strchr(yytext, 'd')+1));
489 <SRV4>M\ [0-9]+d[0-9]+\n rcsrang2(atoi(yytext+2), atoi(yytext+2), atoi(strchr(yytext, 'd')+1));
490 <SRV4>M\ [0-9]+a[0-9]+,[0-9]+\n rcsrang3(atoi(yytext+2), atoi(strchr(yytext, 'a')+1), atoi(strchr(yytext, ',')+1));
491 <SRV4>M\ [0-9]+a[0-9]+\n rcsrang3(atoi(yytext+2), atoi(strrchr(yytext, 'a')+1), atoi(strchr(yytext, 'a')+1));
492 <SRV4>M\ >\ .*\n BEGIN SRV5; rcsfwrite(yytext+4, yyleng-5, rcsfiop);
493 <SRV5>M\ >\ .*\n yytext[3] = '\n'; rcsfwrite(yytext+3, yyleng-4, rcsfiop);
494 <SRV5>""/M\ [0-9] BEGIN SRV4; putc('\n', rcsfiop);
495 <SRV5>M\ \\\ .*\n BEGIN SRV6;
496 <SRV1,SRV4>M\ RCS\ file:.*\n |
497 <SRV1,SRV4>M\ ========.*\n |
498 <SRV1,SRV4>M\ retrieving.*\n |
499 <SRV1,SRV4>M\ diff.*\n |
500 <SRV1,SRV4>M\ Index:.*\n |
501 <SRV1>M\ [0-9]+(,[0-9]+)?d[0-9]+\n |
502 <SRV4>M\ \\\ .*\n |
503 <SRV4>M\ (<\ .*|---)\n /* ignore */
504 <SRV5>([^M\n]|M([^ \n]|\ [^0-9\n])).*\n? |
505 <SRV5>M\ ?\n? |
506 <SRV0,SRV1,SRV2,SRV3,SRV4,SRV6>.*\n? fwrite(yytext, 1, yyleng, stderr);
508 <PWF0>\/1\ [^ \n]+\ .*\n if (chkroot(yytext+3, yyleng-4, 1)) return 0;
509 <PWF0>[^ \n]+\ .*\n if (chkroot(yytext, yyleng-1, 0)) return 0;
510 <PWF0>.*\n? /* ignore unknown lines */
511 <PWF0><<EOF>> return EOF;
513 <HDR0>[^t\n].*\n? |
514 <HDR0>t[^\t\n]* |
515 <TAGL0,LCKL0>\t[^:\n]*:?\n? |
516 <TAGL0,LCKL0>\t[^:\n]*:[^ ].*\n? |
517 <TAGL0,LCKL0>\t[^:\n]*:\ |
518 <ACCL0>\t.*\n? |
519 <REV0>[^\t\n]*[\t\n]? |
520 <REV2>[^;\n]*(""|;\ ?) |
521 <ATR0>[^l\n][^;\n]* |
522 <ATR0>[^l\n][^;\n]*;\ ? |
523 <ATR0>(\n|l[^ \n]*) |
524 <ATR0>lines:\ [^ \n]* |
525 <ATR1,RLST>[^;\n]* |
526 <ATR1>[^;\n]*;\ ? |
527 <HDR1,DESC,TAGL1>.*\n? |
528 <LCKL1,REV1,REV3>.*\n? |
529 <REV4,XREV,SRVA>.*\n? |
530 <SRVB>.*\n? |
531 (.|\n) printf("Unmached: <%.*s>\n", yyleng, yytext);
532 %%
534 static YY_BUFFER_STATE yybuf;
535 /* Read rlog to buffer */
536 size_t rlread(char *ptr, size_t nmemb, FILE *stream)
537 {
538 char *top = ptr;
539 static int state;
540 while (nmemb--) {
541 register int c = getc(stream);
543 if (c == EOF) {
544 state = 0;
545 return ptr - top;
546 }
547 *ptr++ = c;
548 if (c == '\n') {
549 if (state == 77) {
550 state = 0;
551 return ptr - top;
552 }
553 state = 0;
554 } else if (state < 78) {
555 if (c == '=')
556 state++;
557 else
558 state = 78;
559 }
560 }
561 return ptr - top;
562 }
564 void *ftobuf(FILE *stream, unsigned long *s)
565 {
566 unsigned long siz = 0;
567 void *buf = NULL;
568 do {
569 buf = realloc(buf, siz + BUFSIZ + 2);
570 siz += fread(buf + siz, 1, BUFSIZ, stream);
571 /*siz += rlread(buf + siz, BUFSIZ, stream);*/
572 } while (siz && !(siz % BUFSIZ));
573 *s = siz += 2;
575 if (*s == 2) {
576 free(buf);
577 return NULL;
578 }
579 return realloc(buf, siz);
580 }
582 char *strfix(char *s)
583 {
584 unsigned long l = strlen(s);
585 if (!l)
586 return s;
587 if (s[l-1] == '\n')
588 s[l-1] = '\0';
589 return s;
590 }
591 FILE *srv, *rlog_input;
593 FILE *srvopen(void)
594 {
595 #ifndef XTEST
596 struct hostent *host;
597 struct servent *serv;
598 struct sockaddr_in sin;
599 int fd;
600 #endif
601 char *cvsport = NULL;
602 if (strncmp(cvsroot, ":pserver:", 9)
603 || !(cvsdir = strchr(cvsuser = cvsroot + 9, ':'))
604 || !(cvshost = strchr(cvsuser, '@')) || cvshost > cvsdir)
605 return NULL;
606 *cvshost++ = *cvsdir++ = '\0';
607 if (isdigit(*cvsdir)) {
608 cvsport = cvsdir;
609 while (isdigit(*++cvsdir))
610 continue;
611 }
612 #ifndef XTEST
613 memset(&sin, '\0', sizeof sin);
614 if (cvsport)
615 sin.sin_port = htons(atoi(cvsport));
616 else if (!(serv = getservbyname("cvspserver", "tcp")))
617 return NULL;
618 else
619 sin.sin_port = serv->s_port;
620 if (!(host = gethostbyname(cvshost))
621 || (fd = socket(PF_INET, SOCK_STREAM, 0)) == -1)
622 return NULL;
623 sin.sin_family = AF_INET;
624 memcpy(&sin.sin_addr, host->h_addr, host->h_length);
625 if (connect(fd, (struct sockaddr *)&sin, sizeof sin) == -1) {
626 close(fd);
627 return NULL;
628 }
629 return fdopen(fd, "w+");
630 #else
631 return NULL;
632 #endif
633 }
634 char *getpar(char *s)
635 {
636 char *p = NULL, *q = NULL;
637 while (*s)
638 if (*s == '.')
639 p = q, q = s++;
640 else
641 s++;
642 return p;
643 }
645 struct rev *range(struct rev *begin)
646 {
647 char *brb, *bre;
648 if (begin >= rfile.revt)
649 return NULL;
650 brb = begin->num;
651 bre = strrchr(brb, '.');
652 if (!bre || bre == strchr(brb, '.'))
653 bre = brb;
654 else
655 bre++;
656 /*fprintf(stderr, "brb: %s, n: %u\n", brb, bre - brb);*/
657 while (begin < rfile.revt
658 && (bre - brb ? !strncmp(begin->num, brb, bre - brb)
659 && !strchr(begin->num + (bre - brb), '.')
660 : strchr(begin->num, '.') == strrchr(begin->num, '.')))
661 /* works fine even if no '.' present */
662 begin++;
663 return begin;
664 }
666 /*
667 :
668 1.4
669 |
670 1.3 | next
671 | v
672 1.2 branch
673 | ------>
674 1.1--1.1.1.1--1.1.1.1.1.1 - -
675 |
676 1.1.2.1 | sub
677 | v
678 1.1.3.1
679 :
682 next branch sub T
683 v - /1.2
684 * | - |1.1*
685 : : : F B
686 * | | -> | / <1.1.2.1*
687 : : : : :
688 * | | - | | | /1.1.1.2
689 ^ | -> - | - | | |1.1.1.1*
690 : : : : : : F B
691 * | | | | | | / /1.1.1.2.1.2
692 ^ | | -> | | | \ \1.1.1.2.1.1*
693 : : : : : F B
694 * | | | | | / /1.1.1.1.1.2
695 ^ | -> | \ \ \ \1.1.1.1.1.1*
696 : : B
697 * | | / /1.2.1.2
698 ^ -> \ \ \1.2.1.1*
700 */
701 int prefix(const char *rev, const char *subrev)
702 {
703 size_t l = strlen(rev);
704 return !strncmp(rev, subrev, l) && subrev[l] == '.';
705 }
707 /* parse forest belonging to revision x */
708 struct rev *forest(struct rev *x, struct rev **b)
709 {
710 struct rev *z = NULL;
711 do {
712 struct rev *branch(struct rev **b);
713 struct rev *y = branch(b);
714 y->sub = z;
715 z = y;
716 } while (*b < rfile.revt && prefix(x->num, (*b)->num));
717 return z;
718 }
719 /* parse branch */
720 struct rev *branch(struct rev **b)
721 {
722 struct rev *e = range(*b), *x, *y = *b;
723 (*b)->next = NULL;
724 for (x = *b; x < e - 1; x++)
725 x[1].next = x;
726 /* As for the trunk, for each branch revision, a forest can follow.
727 * However here the forests in decreasing order match the order
728 * of the branch revisions.
729 */
730 while (e < rfile.revt) {
731 while (y <= x && !prefix(y->num, e->num))
732 y++->branch = NULL;
733 if (y > x)
734 break;
735 y->branch = forest(y, &e);
736 y++;
737 }
738 *b = e;
739 return x;
740 }
742 /* parse trunk */
743 struct rev *trunk(struct rev *b)
744 {
745 struct rev *e = b ? range(b) : NULL, *x, *y = e;
746 if (!e)
747 return NULL;
748 for (x = b; x < e - 1; x++)
749 x->next = x + 1;
750 x->next = NULL;
751 /* For each trunk revision, a forest can follow.
752 * The forests are in increasing order, in contrast to the
753 * trunk revisions, which are in decreasing order.
754 */
755 while (e < rfile.revt) {
756 /* search the trunk revision this forest belongs to */
757 while (y > b && !prefix((--y)->num, e->num))
758 y->branch = NULL;
759 assert(y > b || prefix(y->num, e->num));
760 /* parse the forest, set branch of the trunk revision */
761 y->branch = forest(y, &e);
762 }
763 return b;
764 }
766 struct {
767 int ndeltas, nfiles, nbranches;
768 } stats;
770 void rcsfputs(const char *s, FILE *stream)
771 {
772 for (putc('@', stream); *s; putc(*s++, stream))
773 if (*s == '@')
774 putc(*s, stream);
775 putc('@', stream);
776 }
777 void puttree(struct rev *x, FILE *stream)
778 {
779 struct rev *y, *z;
780 void putforest(struct rev *x, FILE *stream);
781 for (y = x; y; y = y->next) {
782 struct tm *tm;
783 tm = gmtime(&y->date);
784 fprintf(stream, "%s\n", y->num);
785 fprintf(stream, "date\t%d.%02d.%02d.%02d.%02d.%02d;"
786 "\tauthor %s;\tstate %s;\n",
787 tm->tm_year > 99 ? tm->tm_year + 1900 : tm->tm_year,
788 tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min,
789 tm->tm_sec, y->author, y->state);
790 fprintf(stream, "branches");
791 for (z = y->branch; z; z = z->sub)
792 fprintf(stream, "\n\t%s", z->num);
794 fprintf(stream, ";\n");
795 fprintf(stream, "next\t%s;\n", y->next ? y->next->num : "");
796 fprintf(stream, "\n");
797 }
798 putforest(x, stream);
799 }
800 void putforest(struct rev *x, FILE *stream)
801 {
802 struct rev *z;
803 if (!x)
804 return;
805 putforest(x->next, stream);
806 for (z = x->branch; z; z = z->sub)
807 puttree(z, stream);
808 }
809 void unqueue(void)
810 {
811 ssize_t s;
812 if (que == queue + queuel)
813 return;
814 fcntl(fileno(srv), F_SETFL, O_NONBLOCK);
815 if ((s = write(fileno(srv), que, queue + queuel - que)) != -1)
816 que += s;
817 fcntl(fileno(srv), F_SETFL, 0L);
818 }
819 char *fi, *fi2;
820 void puttree2(struct rev *z, struct rev *x)
821 {
822 struct rev *y;
823 for (y = x; y; y = y->next) {
824 void putfor2(struct rev *z, struct rev *x);
826 if (!z) {
827 for (z = y; z && !strcmp(z->state, "dead"); z = z->next)
828 continue;
829 if (z) {
830 sprintf(getq(10*5+5+3+2+3+2+strlen(z->num)
831 + (fi2 - strrchr(fi, '/')) - 1),
832 "Argument -kb\n"
833 "Argument -r%s\n"
834 "Argument -aN\n"
835 "Argument --\n"
836 "Argument %.*s\n"
837 "diff", z->num,
838 (int)(fi2 - strrchr(fi, '/') - 1),
839 strrchr(fi, '/') + 1);
840 queue[queuel-1] = '\n';
841 } else
842 /* file was initially added on branch */
843 z = y;
844 } else if (strcmp(y->state, "dead") && z != y) {
845 sprintf(getq(10*6+5+3+2+2+3+2+strlen(z->num)
846 + strlen(y->num)
847 + (fi2 - strrchr(fi, '/'))),
848 "Argument -kb\n"
849 "Argument -r%s\n"
850 "Argument -r%s\n"
851 "Argument -aN\n"
852 "Argument --\n"
853 "Argument %.*s\n"
854 "diff", z->num, y->num,
855 (int)(fi2 - strrchr(fi, '/') - 1),
856 strrchr(fi, '/') + 1);
857 queue[queuel-1] = '\n';
858 z = y;
859 }
860 putfor2(z, y->branch);
861 }
862 }
863 void putfor2(struct rev *z, struct rev *x)
864 {
865 if (!x)
866 return;
867 putfor2(z, x->sub);
868 puttree2(z, x);
869 }
870 void puttree3(struct rev *z, struct rev *x)
871 {
872 struct rev *y;
873 for (y = x; y; y = y->next) {
874 void putfor3(struct rev *z, struct rev *x);
875 fprintf(stderr, "%s ", y->num);
877 stats.ndeltas++;
878 fprintf(rcsfiop, "\n\n%s\nlog\n", y->num);
879 rcsfputs(y->log, rcsfiop);
880 fprintf(rcsfiop, "\ntext\n@");
882 if (!z) {
883 for (z = y; z && !strcmp(z->state, "dead"); z = z->next)
884 continue;
885 if (z) {
886 unqueue();
887 BEGIN SRV1;
888 yylex();
889 } else
890 /* file was initially added on branch */
891 z = y;
892 } else if (strcmp(y->state, "dead") && z != y) {
893 unqueue();
894 BEGIN SRV4;
895 yylex();
896 z = y;
897 }
898 fprintf(rcsfiop, "@\n");
899 putfor3(z, y->branch);
900 }
901 }
902 void putfor3(struct rev *z, struct rev *x)
903 {
904 if (!x)
905 return;
906 stats.nbranches++;
907 putfor3(z, x->sub);
908 puttree3(z, x);
909 }
911 /* table of comment leader pairs, merged from RCS and CVS */
912 static const struct clpair {
913 char *suffix, *comlead;
914 } cltbl[] = {
915 { "a" , "-- " }, /* Ada */
916 { "ada" , "-- " },
917 { "adb" , "-- " },
918 { "ads" , "-- " },
919 { "asm" , ";; " }, /* assembler (MS-DOS) */
920 { "bas" , "' " }, /* Visual Basic code */
921 { "bat" , ":: " }, /* batch (MS-DOS) */
922 { "body", "-- " }, /* Ada */
923 { "c" , " * " }, /* C */
924 { "c++" , "// " }, /* C++ in all its infinite guises */
925 { "cc" , "// " },
926 { "cpp" , "// " },
927 { "cxx" , "// " },
928 { "cl" , ";;; "}, /* Common Lisp */
929 { "cmd" , ":: " }, /* command (OS/2) */
930 { "cmf" , "c " }, /* CM Fortran */
931 { "cs" , " * " }, /* C* */
932 { "csh" , "# " }, /* shell */
933 { "dlg" , " * " }, /* MS Windows dialog file */
934 { "e" , "# " }, /* efl */
935 { "epsf", "% " }, /* encapsulated postscript */
936 { "epsi", "% " }, /* encapsulated postscript */
937 { "el" , "; " }, /* Emacs Lisp */
938 { "f" , "c " }, /* Fortran */
939 { "for" , "c " },
940 { "frm" , "' " }, /* Visual Basic form */
941 { "h" , " * " }, /* C-header */
942 { "hh" , "// " },
943 { "hpp" , "// " }, /* C++ header */
944 { "hxx" , "// " },
945 { "in" , "# " }, /* for Makefile.in */
946 { "l" , " * " }, /* lex (NOTE: franzlisp disagrees) */
947 { "lisp", ";;; "}, /* Lucid Lisp */
948 { "lsp" , ";; " }, /* Microsoft Lisp */
949 { "m" , "// " }, /* Objective C */
950 { "mac" , ";; " }, /* macro (DEC-10, MS-DOS, PDP-11, VMS, etc) */
951 { "mak" , "# " }, /* makefile, e.g. Visual C++ */
952 { "me" , ".\\\" "}, /* troff -me */
953 { "ml" , "; " }, /* mocklisp */
954 { "mm" , ".\\\" "}, /* troff -mm */
955 { "ms" , ".\\\" "}, /* troff -ms */
956 { "man" , ".\\\" "}, /* man-macros t/nroff */
957 { "1" , ".\\\" "}, /* feeble attempt at man pages... */
958 { "2" , ".\\\" "},
959 { "3" , ".\\\" "},
960 { "4" , ".\\\" "},
961 { "5" , ".\\\" "},
962 { "6" , ".\\\" "},
963 { "7" , ".\\\" "},
964 { "8" , ".\\\" "},
965 { "9" , ".\\\" "},
966 { "p" , " * " }, /* Pascal */
967 { "pas" , " * " },
968 { "pl" , "# " }, /* perl (conflict with Prolog) */
969 { "ps" , "% " }, /* PostScript */
970 { "psw" , "% " }, /* postscript wrap */
971 { "pswm", "% " }, /* postscript wrap */
972 { "r" , "# " }, /* ratfor */
973 { "rc" , " * " }, /* Microsoft Windows resource file */
974 { "red" , "% " }, /* psl/rlisp */
975 #ifdef sparc
976 { "s" , "! " }, /* assembler */
977 #endif
978 #ifdef mc68000
979 { "s" , "| " }, /* assembler */
980 #endif
981 #ifdef pdp11
982 { "s" , "/ " }, /* assembler */
983 #endif
984 #ifdef vax
985 { "s" , "# " }, /* assembler */
986 #endif
987 #ifdef __ksr__
988 { "s" , "# " }, /* assembler */
989 { "S" , "# " }, /* Macro assembler */
990 #endif
991 { "sh" , "# " }, /* shell */
992 { "sl" , "% " }, /* psl */
993 { "spec", "-- " }, /* Ada */
994 { "sty" , "% " }, /* LaTeX style */
995 { "tex" , "% " }, /* TeX */
996 { "y" , " * " }, /* yacc */
997 { "ye" , " * " }, /* yacc-efl */
998 { "yr" , " * " }, /* yacc-ratfor */
999 { "" , "# " }, /* default for empty suffix */
1000 { 0 , "# " } /* default for unknown suffix; must be last */
1001 };
1003 static int is_version_number(const char *line)
1004 {
1005 if (*line < '0' || *line > '9')
1006 return 0;
1007 for (; *line; line++)
1008 if (*line != '\n' && *line != '.' &&
1009 (*line < '0' || *line > '9'))
1010 return 0;
1011 return 1;
1012 }
1014 static int is_done(const char *filename)
1015 {
1016 char buffer[1024], line[1024];
1017 FILE *orig;
1018 int remaining = rfile.sel;
1020 snprintf(buffer, sizeof(buffer), "%s.old", filename);
1021 orig = fopen(buffer, "rb");
1022 if (!orig)
1023 return 0;
1025 if (!fgets(line, sizeof(line), orig) || strncmp(line, "head\t", 5)) {
1026 fclose(orig);
1027 return 0;
1028 }
1030 while (!feof(orig) && fgets(line, sizeof(line), orig)) {
1031 if (!strcmp(line, "desc\n"))
1032 break;
1033 if (is_version_number(line))
1034 remaining--;
1035 }
1037 fclose(orig);
1038 if (!remaining)
1039 rename(buffer, filename);
1040 else
1041 unlink(buffer);
1042 return !remaining;
1043 }
1045 static const char *current_file;
1046 static void unlink_current_file(int dummy)
1047 {
1048 if (current_file)
1049 unlink(current_file);
1050 exit(1);
1051 }
1053 void gen()
1054 {
1055 size_t l = strlen(cvsdir);
1056 char **i, suffix[6] = "";
1057 struct rpair *j;
1058 fprintf(stderr, "%s\n", rfile.source);
1059 fi = strrchr(rfile.source, '/');
1060 sprintf(getq(12 + (fi - rfile.source) + 1),
1061 "Directory .\n%.*s",
1062 (int)(fi - rfile.source), rfile.source);
1063 queue[queuel-1] = '\n';
1064 fi2 = strrchr(fi, ',');
1065 fi = strrchr(fi, '.');
1066 assert(fi2 && (!fi || fi < fi2));
1067 if (fi) {
1068 fi++;
1069 /* If the suffix length is greater than four characters,
1070 * it cannot match, since it copies five of them.
1071 */
1072 strncpy(suffix, fi, fi2 - fi < sizeof suffix - 1
1073 ? fi2 - fi : sizeof suffix - 1);
1074 }
1075 fi = rfile.source + l + 1;
1076 if (is_done(fi))
1077 return;
1078 current_file = fi;
1079 rcsfiop = fopen(fi, "w");
1081 fprintf(rcsfiop, "head\t%s;\n", rfile.head.num ? rfile.head.num : "");
1082 if (rfile.branch.num)
1083 fprintf(rcsfiop, "branch\t%s;\n", rfile.branch.num);
1084 fprintf(rcsfiop, "access");
1085 for (i = rfile.accl; i < rfile.acct; i++)
1086 fprintf(rcsfiop, "\n\t%s", *i);
1087 fprintf(rcsfiop, ";\n");
1088 fprintf(rcsfiop, "symbols");
1089 for (j = rfile.tagl; j < rfile.tagt; j++)
1090 fprintf(rcsfiop, "\n\t%s:%s", j->item, j->rev.num);
1091 fprintf(rcsfiop, ";\n");
1092 fprintf(rcsfiop, "locks");
1093 for (j = rfile.lckl; j < rfile.lckt; j++)
1094 fprintf(rcsfiop, "\n\t%s:%s", j->item, j->rev.num);
1095 fprintf(rcsfiop, ";%s\n", rfile.strict ? " strict;" : "");
1096 fprintf(rcsfiop, "comment\t");
1097 if (rfile.leader)
1098 rcsfputs(rfile.leader, rcsfiop);
1099 else {
1100 const struct clpair *curr;
1101 for (curr = cltbl; curr->suffix; curr++)
1102 if (!strcmp(curr->suffix, suffix))
1103 break;
1104 rcsfputs(curr->comlead, rcsfiop);
1105 }
1106 fprintf(rcsfiop, ";\n");
1107 if (rfile.ksub && strcmp(rfile.ksub, "kv")) {
1108 fprintf(rcsfiop, "expand\t");
1109 rcsfputs(rfile.ksub, rcsfiop);
1110 fprintf(rcsfiop, ";\n");
1111 }
1112 fprintf(rcsfiop, "\n\n");
1113 trunk(rfile.revl);
1114 stats.nfiles++;
1115 puttree(rfile.revl, rcsfiop);
1116 fprintf(rcsfiop, "\ndesc\n");
1117 rcsfputs(rfile.descr, rcsfiop);
1118 fprintf(rcsfiop, "\n");
1119 puttree2(NULL, rfile.revl);
1120 que = queue;
1121 puttree3(NULL, rfile.revl);
1122 if (queue)
1123 free(queue);
1124 queue = NULL;
1125 fprintf(stderr, "\n");
1126 fclose(rcsfiop);
1127 current_file = NULL;
1128 }
1129 char *home;
1130 int main(int argc, char *argv[])
1131 {
1132 unsigned long siz;
1133 char *buf, *passfile, *fn0, *fn1, *fn2;
1135 if (argc == 5 || argc == 3)
1136 if (!(rlog_input = fopen(argv[--argc], "rb"))) {
1137 fprintf(stderr, "Invalid rlog file\n");
1138 return EXIT_FAILURE;
1139 }
1141 if (argc == 4 && !strcmp(argv[1], "-d")) {
1142 argc -= 2;
1143 cvsroot = argv[2];
1144 argv[1] = argv[3];
1145 } else if (argc != 2) {
1146 fprintf(stderr, "Argument count.\n");
1147 return EXIT_FAILURE;
1148 } else
1149 cvsroot = getenv("CVSROOT");
1151 if (!cvsroot) {
1152 fprintf(stderr, "No CVSROOT.\n");
1153 return EXIT_FAILURE;
1154 }
1155 cvsroot = strdup(cvsroot);
1156 passfile = (home = getenv("HOME"))
1157 ? strcat(strcpy(malloc(strlen(home)
1158 + sizeof "/.cvspass"), home), "/.cvspass")
1159 : strcpy(malloc(sizeof ".cvspass"), ".cvspass");
1160 BEGIN PWF0;
1161 if (!(yyin = fopen(passfile, "r")) || yylex() == EOF) {
1162 size_t l = strlen(cvsroot);
1163 cvsroot = realloc(cvsroot, l + 2);
1164 cvspass = strcpy(cvsroot + l + 1, "A");
1165 }
1166 if (yyin)
1167 fclose(yyin);
1168 fprintf(stderr, "password file: %s\n"
1169 "cvsroot: %s\n"
1170 "pass: %.1s\n", passfile,
1171 cvsroot, cvspass);
1173 signal(SIGINT, unlink_current_file);
1174 if (!(srv = srvopen())) {
1175 fprintf(stderr, "server connection failed or bad cvsroot\n");
1176 #ifndef XTEST
1177 return EXIT_FAILURE;
1178 #endif
1179 }
1180 #ifndef XTEST
1181 fprintf(srv, "BEGIN AUTH REQUEST\n"
1182 "%s\n"
1183 "%s\n"
1184 "%s\n"
1185 "END AUTH REQUEST\n", cvsdir, cvsuser, cvspass);
1186 fprintf(srv, "Root %s\n", cvsdir);
1187 /*fprintf(srv, "Argument micq/m4\n");*/
1188 fprintf(srv, "Argument %s\n", argv[1]);
1189 if (rlog_input)
1190 yyrestart(rlog_input);
1191 else
1192 {
1193 yyrestart(srv);
1194 fprintf(srv, "rlog\n");
1195 fflush(srv);
1196 }
1197 BEGIN SRV0;
1198 yy_set_interactive(1);
1199 fprintf(stderr, "exit: %d\n", yylex());
1200 fn2 = fn0 = queue;
1201 fn1 = queue + queuel;
1202 queue = NULL;
1203 #else
1204 fn2 = fn0 = malloc(strlen(argv[1]) + 3);
1205 fn1 = strlen(argv[1]) + 3 + strcpy(fn0, argv[1]);
1206 strcat(fn0, ",v");
1207 #endif
1208 while (fn0 < fn1 && (buf = ftobuf(rcsfiop = fopen(fn0, "r"), &siz))) {
1209 fclose(rcsfiop);
1210 fn0 += strlen(fn0) + 1;
1211 buf[siz - 2] = YY_END_OF_BUFFER_CHAR;
1212 buf[siz - 1] = YY_END_OF_BUFFER_CHAR;
1213 /* fprintf(stderr, "<<%s>>\n", buf); */
1214 yybuf = YY_CURRENT_BUFFER;
1215 yy_scan_buffer(buf, siz);
1216 yy_set_interactive(0);
1217 BEGIN HDR0;
1218 rcsinit();
1219 yylex();
1220 assert(YY_CURRENT_BUFFER);
1221 yy_delete_buffer(YY_CURRENT_BUFFER);
1222 yy_switch_to_buffer(yybuf);
1223 gen();
1224 if (rfile.lckl)
1225 free(rfile.lckl);
1226 if (rfile.tagl)
1227 free(rfile.tagl);
1228 if (rfile.accl)
1229 free(rfile.accl);
1230 if (rfile.revl)
1231 free(rfile.revl);
1233 free(buf);
1234 }
1235 if (fn2)
1236 free(fn2);
1237 fprintf(stderr, "%s clone successful: %d files, "
1238 "%d branches, %d deltas\n",
1239 argv[0], stats.nfiles, stats.nbranches, stats.ndeltas);
1240 #ifndef XTEST
1241 fclose(srv);
1242 #endif
1243 return EXIT_SUCCESS;
1244 }