Mercurial > noffle
annotate client.c @ 10:d3fb34cb8198 noffle
[svn] Added comment
author | enz |
---|---|
date | Tue, 11 Apr 2000 07:50:16 +0100 |
parents | 6e822f4b19f9 |
children | ab6cf19be6d3 |
rev | line source |
---|---|
0 | 1 /* |
2 client.c | |
3 | |
6
6e822f4b19f9
[svn] Set Client-Authenticated flag to False on connection to server.
enz
parents:
0
diff
changeset
|
4 $Id: client.c 11 2000-02-10 19:27:17Z enz $ |
0 | 5 */ |
6 | |
7 #include "client.h" | |
8 | |
9 #include <arpa/inet.h> | |
10 #include <ctype.h> | |
11 #include <netdb.h> | |
12 #include <netinet/in.h> | |
13 #include <signal.h> | |
14 #include <stdarg.h> | |
15 #include <sys/socket.h> | |
16 #include <unistd.h> | |
17 #include "config.h" | |
18 #include "content.h" | |
19 #include "dynamicstring.h" | |
20 #include "group.h" | |
21 #include "log.h" | |
22 #include "over.h" | |
23 #include "protocol.h" | |
24 #include "pseudo.h" | |
25 #include "request.h" | |
26 #include "util.h" | |
27 | |
28 struct | |
29 { | |
30 FILE* in; /* Receiving socket from server */ | |
31 FILE* out; /* Sending socket to server */ | |
32 Str lastCmd; /* Last command line */ | |
33 Str lastStat; /* Response from server to last command */ | |
34 Str grp; /* Selected group */ | |
35 int rmtFirst; /* First article of current group at server */ | |
36 int rmtLast; /* Last article of current group at server */ | |
37 Bool auth; /* Authetication already done? */ | |
38 Str serv; /* Remote server name */ | |
39 } client = { NULL, NULL, "", "", "", 1, 0, FALSE, "" }; | |
40 | |
41 static void | |
42 logBreakDown( void ) | |
43 { | |
44 Log_err( "Connection to remote server lost " | |
45 "(article numbers could be inconsistent)" ); | |
46 } | |
47 | |
48 static Bool | |
49 getLn( Str line ) | |
50 { | |
51 Bool r; | |
52 | |
53 r = Prt_getLn( line, client.in ); | |
54 if ( ! r ) | |
55 logBreakDown(); | |
56 return r; | |
57 } | |
58 | |
59 static Bool | |
60 getTxtLn( Str line, Bool *err ) | |
61 { | |
62 Bool r; | |
63 | |
64 r = Prt_getTxtLn( line, err, client.in ); | |
65 if ( *err ) | |
66 logBreakDown(); | |
67 return r; | |
68 } | |
69 | |
70 static void | |
71 putTxtBuf( const char *buf ) | |
72 { | |
73 Prt_putTxtBuf( buf, client.out ); | |
74 fflush( client.out ); | |
75 Log_dbg( "[S FLUSH]" ); | |
76 } | |
77 | |
78 static void | |
79 putEndOfTxt( void ) | |
80 { | |
81 Prt_putEndOfTxt( client.out ); | |
82 fflush( client.out ); | |
83 Log_dbg( "[S FLUSH]" ); | |
84 } | |
85 | |
86 static Bool | |
87 putCmd( const char *fmt, ... ) | |
88 { | |
89 Bool err; | |
90 unsigned int n; | |
91 Str line; | |
92 va_list ap; | |
93 | |
94 va_start( ap, fmt ); | |
95 vsnprintf( line, MAXCHAR, fmt, ap ); | |
96 va_end( ap ); | |
97 strcpy( client.lastCmd, line ); | |
98 Log_dbg( "[S] %s", line ); | |
99 n = fprintf( client.out, "%s\r\n", line ); | |
100 fflush( client.out ); | |
101 Log_dbg( "[S FLUSH]" ); | |
102 err = ( n != strlen( line ) + 2 ); | |
103 if ( err ) | |
104 logBreakDown();; | |
105 return ! err; | |
106 } | |
107 | |
108 static Bool | |
109 putCmdNoFlush( const char *fmt, ... ) | |
110 { | |
111 Bool err; | |
112 unsigned int n; | |
113 Str line; | |
114 va_list ap; | |
115 | |
116 va_start( ap, fmt ); | |
117 vsnprintf( line, MAXCHAR, fmt, ap ); | |
118 va_end( ap ); | |
119 strcpy( client.lastCmd, line ); | |
120 Log_dbg( "[S] %s", line ); | |
121 n = fprintf( client.out, "%s\r\n", line ); | |
122 err = ( n != strlen( line ) + 2 ); | |
123 if ( err ) | |
124 logBreakDown();; | |
125 return ! err; | |
126 } | |
127 | |
128 static int getStat( void ); | |
129 | |
130 static Bool | |
131 performAuth( void ) | |
132 { | |
133 int stat; | |
134 Str user, pass; | |
135 | |
136 Cfg_authInfo( client.serv, user, pass ); | |
137 if ( strcmp( user, "" ) == 0 ) | |
138 { | |
139 Log_err( "No username for authentication set" ); | |
140 return FALSE; | |
141 } | |
142 putCmd( "AUTHINFO USER %s", user ); | |
143 stat = getStat(); | |
144 if ( stat == STAT_AUTH_ACCEPTED ) | |
145 return TRUE; | |
146 else if ( stat != STAT_MORE_AUTH_REQUIRED ) | |
147 { | |
148 Log_err( "Username rejected. Server stat: %s", client.lastStat ); | |
149 return FALSE; | |
150 } | |
151 if ( strcmp( pass, "" ) == 0 ) | |
152 { | |
153 Log_err( "No password for authentication set" ); | |
154 return FALSE; | |
155 } | |
156 putCmd( "AUTHINFO PASS %s", pass ); | |
157 stat = getStat(); | |
158 if ( stat != STAT_AUTH_ACCEPTED ) | |
159 { | |
160 Log_err( "Password rejected. Server status: %s", client.lastStat ); | |
161 return FALSE; | |
162 } | |
163 return TRUE; | |
164 } | |
165 | |
166 static int | |
167 getStat( void ) | |
168 { | |
169 int result; | |
170 Str lastCmd; | |
171 | |
172 if ( ! getLn( client.lastStat ) ) | |
173 result = STAT_PROGRAM_FAULT; | |
174 else if ( sscanf( client.lastStat, "%d", &result ) != 1 ) | |
175 { | |
176 Log_err( "Invalid server status: %s", client.lastStat ); | |
177 result = STAT_PROGRAM_FAULT; | |
178 } | |
179 if ( result == STAT_AUTH_REQUIRED && ! client.auth ) | |
180 { | |
181 client.auth = TRUE; | |
182 strcpy( lastCmd, client.lastCmd ); | |
183 if ( performAuth() ) | |
184 { | |
185 putCmd( lastCmd ); | |
186 return getStat(); | |
187 } | |
188 } | |
189 return result; | |
190 } | |
191 | |
192 static void | |
193 connectAlarm( int sig ) | |
194 { | |
195 return; | |
196 } | |
197 | |
198 static sig_t | |
199 installSignalHandler( int sig, sig_t handler ) | |
200 { | |
201 struct sigaction act, oldAct; | |
202 | |
203 act.sa_handler = handler; | |
204 sigemptyset( &act.sa_mask ); | |
205 act.sa_flags = 0; | |
206 if ( sig == SIGALRM ) | |
207 act.sa_flags |= SA_INTERRUPT; | |
208 else | |
209 act.sa_flags |= SA_RESTART; | |
210 if ( sigaction( sig, &act, &oldAct ) < 0 ) | |
211 return SIG_ERR; | |
212 return oldAct.sa_handler; | |
213 } | |
214 | |
215 static Bool | |
216 connectWithTimeout( int sock, const struct sockaddr *servAddr, | |
217 socklen_t addrLen ) | |
218 { | |
219 sig_t oldHandler; | |
220 int r, to; | |
221 | |
222 oldHandler = installSignalHandler( SIGALRM, connectAlarm ); | |
223 if ( oldHandler == SIG_ERR ) | |
224 { | |
225 Log_err( "client.c:connectWithTimeout: signal failed." ); | |
226 return FALSE; | |
227 } | |
228 to = Cfg_connectTimeout(); | |
229 if ( alarm( to ) != 0 ) | |
230 Log_err( "client.c:connectWithTimeout: Alarm was already set." ); | |
231 r = connect( sock, servAddr, addrLen ); | |
232 alarm( 0 ); | |
233 installSignalHandler( SIGALRM, oldHandler ); | |
234 return ( r >= 0 ); | |
235 } | |
236 | |
237 Bool | |
238 Client_connect( const char *serv ) | |
239 { | |
240 unsigned short int port; | |
241 int sock, i; | |
242 unsigned int stat; | |
243 struct hostent *hp; | |
244 char *pStart, *pColon; | |
245 Str host, s; | |
246 struct sockaddr_in sIn; | |
247 | |
6
6e822f4b19f9
[svn] Set Client-Authenticated flag to False on connection to server.
enz
parents:
0
diff
changeset
|
248 client.auth = FALSE; |
0 | 249 Utl_cpyStr( s, serv ); |
250 pStart = Utl_stripWhiteSpace( s ); | |
251 pColon = strstr( pStart, ":" ); | |
252 if ( pColon == NULL ) | |
253 { | |
254 strcpy( host, pStart ); | |
255 port = 119; | |
256 } | |
257 else | |
258 { | |
259 *pColon = '\0'; | |
260 strcpy( host, pStart ); | |
261 if ( sscanf( pColon + 1, "%hi", &port ) != 1 ) | |
262 { | |
263 Log_err( "Syntax error in server name: '%s'", serv ); | |
264 return FALSE;; | |
265 } | |
266 if ( port <= 0 || port > 65535 ) | |
267 { | |
268 Log_err( "Invalid port number %hi. Must be in [1, 65535]", port ); | |
269 return FALSE;; | |
270 } | |
271 } | |
272 memset( (void *)&sIn, 0, sizeof( sIn ) ); | |
273 hp = gethostbyname( host ); | |
274 if ( hp ) | |
275 { | |
276 for ( i = 0; (hp->h_addr_list)[ i ]; ++i ) | |
277 { | |
278 sIn.sin_family = hp->h_addrtype; | |
279 sIn.sin_port = htons( port ); | |
280 sIn.sin_addr = *( (struct in_addr *)hp->h_addr_list[ i ] ); | |
281 sock = socket( AF_INET, SOCK_STREAM, 0 ); | |
282 if ( sock < 0 ) | |
283 break; | |
284 if ( ! connectWithTimeout( sock, (struct sockaddr *)&sIn, | |
285 sizeof( sIn ) ) ) | |
286 { | |
287 close( sock ); | |
288 break; | |
289 } | |
290 if ( ! ( client.out = fdopen( sock, "w" ) ) | |
291 || ! ( client.in = fdopen( dup( sock ), "r" ) ) ) | |
292 { | |
293 close( sock ); | |
294 break; | |
295 } | |
296 stat = getStat(); | |
297 switch( stat ) { | |
298 case STAT_READY_POST_ALLOW: | |
299 case STAT_READY_NO_POST_ALLOW: | |
300 Log_inf( "Connected to %s:%d", | |
301 inet_ntoa( sIn.sin_addr ), port ); | |
302 Utl_cpyStr( client.serv, serv ); | |
303 return TRUE; | |
304 default: | |
305 Log_err( "Bad server stat %d", stat ); | |
306 } | |
307 shutdown( fileno( client.out ), 0 ); | |
308 } | |
309 } | |
310 return FALSE; | |
311 } | |
312 | |
313 static void | |
314 processGrps( void ) | |
315 { | |
316 char postAllow; | |
317 Bool err; | |
318 int first, last; | |
319 Str grp, line, file; | |
320 | |
321 while ( getTxtLn( line, &err ) && ! err ) | |
322 { | |
323 if ( sscanf( line, "%s %i %i %c", | |
324 grp, &last, &first, &postAllow ) != 4 ) | |
325 { | |
326 Log_err( "Unknown reply to LIST or NEWGROUPS: %s", line ); | |
327 continue; | |
328 } | |
329 if ( ! Grp_exists( grp ) ) | |
330 { | |
331 Log_inf( "Registering new group '%s'", grp ); | |
332 Grp_create( grp ); | |
333 /* Start local numbering with remote first number to avoid | |
334 new numbering at the readers if noffle is re-installed */ | |
335 if ( first != 0 ) | |
336 Grp_setFirstLast( grp, first, first - 1 ); | |
337 else | |
338 Grp_setFirstLast( grp, 1, 0 ); | |
339 Grp_setRmtNext( grp, first ); | |
340 Grp_setServ( grp, client.serv ); | |
341 } | |
342 else | |
343 { | |
344 if ( Cfg_servIsPreferential( client.serv, Grp_serv( grp ) ) ) | |
345 { | |
346 Log_inf( "Changing server for '%s': '%s'->'%s'", | |
347 grp, Grp_serv( grp ), client.serv ); | |
348 Grp_setServ( grp, client.serv ); | |
349 Grp_setRmtNext( grp, first ); | |
350 } | |
351 else | |
352 Log_dbg( "Group %s is already fetched from %s", | |
353 grp, Grp_serv( grp ) ); | |
354 | |
355 } | |
356 } | |
357 if ( ! err ) | |
358 { | |
359 snprintf( file, MAXCHAR, "%s/groupinfo.lastupdate", Cfg_spoolDir() ); | |
360 Utl_stamp( file ); | |
361 } | |
362 } | |
363 | |
364 void | |
365 Client_disconnect( void ) | |
366 { | |
367 if ( putCmd( "QUIT" ) ) | |
368 getStat(); | |
369 fclose( client.in ); | |
370 fclose( client.out ); | |
371 client.in = client.out = NULL; | |
372 } | |
373 | |
374 Bool | |
375 Client_getGrps( void ) | |
376 { | |
377 if ( ! putCmd( "LIST ACTIVE" ) ) | |
378 return FALSE; | |
379 if ( getStat() != STAT_GRPS_FOLLOW ) | |
380 { | |
381 Log_err( "LIST ACTIVE command failed: %s", client.lastStat ); | |
382 return FALSE; | |
383 } | |
384 processGrps(); | |
385 return TRUE; | |
386 } | |
387 | |
388 Bool | |
389 Client_getDsc( void ) | |
390 { | |
391 Bool err; | |
392 Str name, line, dsc; | |
393 | |
394 Log_inf( "Querying group descriptions" ); | |
395 if ( ! putCmd( "LIST NEWSGROUPS" ) ) | |
396 return FALSE; | |
397 if ( getStat() != STAT_GRPS_FOLLOW ) | |
398 { | |
399 Log_err( "LIST NEWSGROUPS failed: %s", client.lastStat ); | |
400 return FALSE; | |
401 } | |
402 while ( getTxtLn( line, &err ) && ! err ) | |
403 { | |
404 if ( sscanf( line, "%s", name ) != 1 ) | |
405 { | |
406 Log_err( "Unknown reply to LIST NEWSGROUPS: %s", line ); | |
407 continue; | |
408 } | |
409 strcpy( dsc, Utl_restOfLn( line, 1 ) ); | |
410 if ( Grp_exists( name ) ) | |
411 { | |
412 Log_dbg( "Description of %s: %s", name, dsc ); | |
413 Grp_setDsc( name, dsc ); | |
414 } | |
415 } | |
416 return TRUE; | |
417 } | |
418 | |
419 Bool | |
420 Client_getCreationTimes( void ) | |
421 { | |
422 Bool err; | |
423 Str name, line; | |
424 time_t t; | |
425 | |
426 Log_inf( "Querying group creation times" ); | |
427 if ( ! putCmd( "LIST ACTIVE.TIMES" ) ) | |
428 return FALSE; | |
429 if ( getStat() != STAT_GRPS_FOLLOW ) | |
430 { | |
431 Log_err( "LIST ACTIVE.TIMES failes: %s", client.lastStat ); | |
432 return FALSE; | |
433 } | |
434 while ( getTxtLn( line, &err ) && ! err ) | |
435 { | |
436 if ( sscanf( line, "%s %ld", name, &t ) != 2 ) | |
437 { | |
438 Log_err( "Unknown reply to LIST ACTIVE.TIMES: %s", line ); | |
439 continue; | |
440 } | |
441 if ( Grp_exists( name ) ) | |
442 { | |
443 Log_inf( "Creation time of %s: %ld", name, t ); | |
444 Grp_setCreated( name, t ); | |
445 } | |
446 } | |
447 return TRUE; | |
448 } | |
449 | |
450 Bool | |
451 Client_getNewgrps( const time_t *lastTime ) | |
452 { | |
453 Str s; | |
454 const char *p; | |
455 | |
456 ASSERT( *lastTime > 0 ); | |
457 strftime( s, MAXCHAR, "%Y%m%d %H%M00", gmtime( lastTime ) ); | |
458 /* | |
459 Do not use century for working with old server software until 2000. | |
460 According to newest IETF draft, this is still valid after 2000. | |
461 (directly using %y in fmt string causes a Y2K compiler warning) | |
462 */ | |
463 p = s + 2; | |
464 if ( ! putCmd( "NEWGROUPS %s", p ) ) | |
465 return FALSE; | |
466 if ( getStat() != STAT_NEW_GRP_FOLLOW ) | |
467 { | |
468 Log_err( "NEWGROUPS command failed: %s", client.lastStat ); | |
469 return FALSE; | |
470 } | |
471 processGrps(); | |
472 return TRUE; | |
473 } | |
474 | |
475 static const char * | |
476 readField( Str result, const char *p ) | |
477 { | |
478 size_t len; | |
479 char *r; | |
480 | |
481 if ( ! p ) | |
482 return NULL; | |
483 r = result; | |
484 *r = '\0'; | |
485 len = 0; | |
486 while ( *p != '\t' && *p != '\n' ) | |
487 { | |
488 if ( ! *p ) | |
489 return p; | |
490 *(r++) = *(p++); | |
491 ++len; | |
492 if ( len >= MAXCHAR - 1 ) | |
493 { | |
494 *r = '\0'; | |
495 Log_err( "Field in overview too long: %s", r ); | |
496 return ++p; | |
497 } | |
498 } | |
499 *r = '\0'; | |
500 return ++p; | |
501 } | |
502 | |
503 static Bool | |
504 parseOvLn( Str line, int *numb, Str subj, Str from, | |
505 Str date, Str msgId, Str ref, size_t *bytes, size_t *lines ) | |
506 { | |
507 const char *p; | |
508 Str t; | |
509 | |
510 p = readField( t, line ); | |
511 if ( sscanf( t, "%i", numb ) != 1 ) | |
512 return FALSE; | |
513 p = readField( subj, p ); | |
514 p = readField( from, p ); | |
515 p = readField( date, p ); | |
516 p = readField( msgId, p ); | |
517 p = readField( ref, p ); | |
518 p = readField( t, p ); | |
519 *bytes = 0; | |
520 *lines = 0; | |
521 if ( sscanf( t, "%d", bytes ) != 1 ) | |
522 return TRUE; | |
523 p = readField( t, p ); | |
524 if ( sscanf( t, "%d", lines ) != 1 ) | |
525 return TRUE; | |
526 return TRUE; | |
527 } | |
528 | |
529 static const char* | |
530 nextXref( const char *pXref, Str grp, int *numb ) | |
531 { | |
532 Str s; | |
533 const char *pColon, *src; | |
534 char *dst; | |
535 | |
536 src = pXref; | |
537 while ( *src && isspace( *src ) ) | |
538 ++src; | |
539 dst = s; | |
540 while ( *src && ! isspace( *src ) ) | |
541 *(dst++) = *(src++); | |
542 *dst = '\0'; | |
543 if ( strlen( s ) == 0 ) | |
544 return NULL; | |
545 pColon = strstr( s, ":" ); | |
546 if ( ! pColon || sscanf( pColon + 1, "%i", numb ) != 1 ) | |
547 { | |
548 Log_err( "Corrupt Xref at position '%s'", pXref ); | |
549 return NULL; | |
550 } | |
551 Utl_cpyStrN( grp, s, pColon - s ); | |
552 Log_dbg( "client.c: nextXref: grp '%s' numb %lu", grp, numb ); | |
553 return src; | |
554 } | |
555 | |
556 static Bool | |
557 needsMark( const char *ref ) | |
558 { | |
559 Bool done = FALSE; | |
560 char *p; | |
561 Str msgId; | |
562 int stat, len; | |
563 time_t lastAccess, nowTime; | |
564 double limit; | |
565 | |
566 nowTime = time( NULL ); | |
567 limit = Cfg_threadFollowTime() * 24. * 3600.; | |
568 while ( ! done ) | |
569 { | |
570 p = msgId; | |
571 while ( *ref != '<' ) | |
572 if ( *(ref++) == '\0' ) | |
573 return FALSE; | |
574 len = 0; | |
575 while ( *ref != '>' ) | |
576 { | |
577 if ( *ref == '\0' || ++len >= MAXCHAR - 1 ) | |
578 return FALSE; | |
579 *(p++) = *(ref++); | |
580 } | |
581 *(p++) = '>'; | |
582 *p = '\0'; | |
583 if ( Db_contains( msgId ) ) | |
584 { | |
585 stat = Db_stat( msgId ); | |
586 lastAccess = Db_lastAccess( msgId ); | |
587 if ( ( stat & DB_INTERESTING ) | |
588 && difftime( nowTime, lastAccess ) <= limit ) | |
589 return TRUE; | |
590 } | |
591 } | |
592 return FALSE; | |
593 } | |
594 | |
595 static void | |
596 prepareEntry( Over *ov ) | |
597 { | |
598 Str g, t; | |
599 const char *msgId, *p, *xref; | |
600 int n; | |
601 | |
602 msgId = Ov_msgId( ov ); | |
603 if ( Pseudo_isGeneralInfo( msgId ) ) | |
604 Log_dbg( "Skipping general info '%s'", msgId ); | |
605 else if ( Db_contains( msgId ) ) | |
606 { | |
607 xref = Db_xref( msgId ); | |
608 Log_dbg( "Entry '%s' already in db with Xref '%s'", msgId, xref ); | |
609 p = nextXref( xref, g, &n ); | |
610 if ( p == NULL ) | |
611 Log_err( "Overview with no group in Xref '%s'", msgId ); | |
612 else | |
613 { | |
614 if ( Cfg_servIsPreferential( client.serv, Grp_serv( g ) ) ) | |
615 { | |
616 Log_dbg( "Changing first server for '%s' from '%s' to '%s'", | |
617 msgId, Grp_serv( g ), client.serv ); | |
618 snprintf( t, MAXCHAR, "%s:%i %s", | |
619 client.grp, Ov_numb( ov ), xref ); | |
620 Db_setXref( msgId, t ); | |
621 } | |
622 else | |
623 { | |
624 Log_dbg( "Adding '%s' to Xref of '%s'", g, msgId ); | |
625 snprintf( t, MAXCHAR, "%s %s:%i", | |
626 xref, client.grp, Ov_numb( ov ) ); | |
627 Db_setXref( msgId, t ); | |
628 } | |
629 } | |
630 } | |
631 else | |
632 { | |
633 Log_dbg( "Preparing '%s' in database", msgId ); | |
634 Db_prepareEntry( ov, client.grp, Ov_numb( ov ) ); | |
635 } | |
636 } | |
637 | |
638 Bool | |
639 Client_getOver( int rmtFirst, int rmtLast, FetchMode mode ) | |
640 { | |
641 Bool err; | |
642 size_t bytes, lines; | |
643 int rmtNumb, oldLast, cntMarked; | |
644 Over *ov; | |
645 Str line, subj, from, date, msgId, ref; | |
646 | |
647 ASSERT( strcmp( client.grp, "" ) != 0 ); | |
648 if ( ! putCmd( "XOVER %lu-%lu", rmtFirst, rmtLast ) ) | |
649 return FALSE; | |
650 if ( getStat() != STAT_OVERS_FOLLOW ) | |
651 { | |
652 Log_err( "XOVER command failed: %s", client.lastStat ); | |
653 return FALSE; | |
654 } | |
655 Log_dbg( "Requesting overview for remote %lu-%lu", rmtFirst, rmtLast ); | |
656 oldLast = Cont_last(); | |
657 cntMarked = 0; | |
658 while ( getTxtLn( line, &err ) && ! err ) | |
659 { | |
660 if ( ! parseOvLn( line, &rmtNumb, subj, from, date, msgId, ref, | |
661 &bytes, &lines ) ) | |
662 Log_err( "Bad overview line: %s", line ); | |
663 else | |
664 { | |
665 ov = new_Over( subj, from, date, msgId, ref, bytes, lines ); | |
666 Cont_app( ov ); | |
667 prepareEntry( ov ); | |
668 if ( mode == FULL || ( mode == THREAD && needsMark( ref ) ) ) | |
669 { | |
670 Req_add( client.serv, msgId ); | |
671 ++cntMarked; | |
672 } | |
673 } | |
674 Grp_setRmtNext( client.grp, rmtNumb + 1 ); | |
675 } | |
676 if ( oldLast != Cont_last() ) | |
677 Log_inf( "Added %s %lu-%lu", client.grp, oldLast + 1, Cont_last() ); | |
678 Log_inf( "%u articles marked for download in %s", cntMarked, client.grp ); | |
679 return err; | |
680 } | |
681 | |
682 static void | |
683 retrievingFailed( const char* msgId, const char *reason ) | |
684 { | |
685 int stat; | |
686 | |
687 Log_err( "Retrieving of %s failed: %s", msgId, reason ); | |
688 stat = Db_stat( msgId ); | |
689 Pseudo_retrievingFailed( msgId, reason ); | |
690 Db_setStat( msgId, stat | DB_RETRIEVING_FAILED ); | |
691 } | |
692 | |
693 static Bool | |
694 retrieveAndStoreArt( const char *msgId ) | |
695 { | |
696 Bool err; | |
697 DynStr *s = NULL; | |
698 Str line; | |
699 | |
700 Log_inf( "Retrieving %s", msgId ); | |
701 s = new_DynStr( 5000 ); | |
702 while ( getTxtLn( line, &err ) && ! err ) | |
703 DynStr_appLn( s, line ); | |
704 if ( ! err ) | |
705 Db_storeArt( msgId, DynStr_str( s ) ); | |
706 else | |
707 retrievingFailed( msgId, "Connection broke down" ); | |
708 del_DynStr( s ); | |
709 return ! err; | |
710 } | |
711 | |
712 void | |
713 Client_retrieveArt( const char *msgId ) | |
714 { | |
715 if ( ! Db_contains( msgId ) ) | |
716 { | |
717 Log_err( "Article '%s' not prepared in database. Skipping.", msgId ); | |
718 return; | |
719 } | |
720 if ( ! ( Db_stat( msgId ) & DB_NOT_DOWNLOADED ) ) | |
721 { | |
722 Log_inf( "Article '%s' already retrieved. Skipping.", msgId ); | |
723 return; | |
724 } | |
725 if ( ! putCmd( "ARTICLE %s", msgId ) ) | |
726 retrievingFailed( msgId, "Connection broke down" ); | |
727 else if ( getStat() != STAT_ART_FOLLOWS ) | |
728 retrievingFailed( msgId, client.lastStat ); | |
729 else | |
730 retrieveAndStoreArt( msgId ); | |
731 } | |
732 | |
733 void | |
734 Client_retrieveArtList( const char *list ) | |
735 { | |
736 Str msgId; | |
737 DynStr *s; | |
738 const char *p; | |
739 | |
740 Log_inf( "Retrieving article list" ); | |
741 s = new_DynStr( strlen( list ) ); | |
742 p = list; | |
743 while ( ( p = Utl_getLn( msgId, p ) ) ) | |
744 if ( ! Db_contains( msgId ) ) | |
745 Log_err( "Skipping retrieving of %s (not prepared in database)", | |
746 msgId ); | |
747 else if ( ! ( Db_stat( msgId ) & DB_NOT_DOWNLOADED ) ) | |
748 Log_inf( "Skipping %s (already retrieved)", msgId ); | |
749 else if ( ! putCmdNoFlush( "ARTICLE %s", msgId ) ) | |
750 { | |
751 retrievingFailed( msgId, "Connection broke down" ); | |
752 del_DynStr( s ); | |
753 return; | |
754 } | |
755 else | |
756 DynStr_appLn( s, msgId ); | |
757 fflush( client.out ); | |
758 Log_dbg( "[S FLUSH]" ); | |
759 p = DynStr_str( s ); | |
760 while ( ( p = Utl_getLn( msgId, p ) ) ) | |
761 { | |
762 if ( getStat() != STAT_ART_FOLLOWS ) | |
763 retrievingFailed( msgId, client.lastStat ); | |
764 else if ( ! retrieveAndStoreArt( msgId ) ) | |
765 break; | |
766 } | |
767 del_DynStr( s ); | |
768 } | |
769 | |
770 Bool | |
771 Client_changeToGrp( const char* name ) | |
772 { | |
773 unsigned int stat; | |
774 int estimatedNumb, first, last; | |
775 | |
776 if ( ! Grp_exists( name ) ) | |
777 return FALSE; | |
778 if ( ! putCmd( "GROUP %s", name ) ) | |
779 return FALSE; | |
780 if ( getStat() != STAT_GRP_SELECTED ) | |
781 return FALSE; | |
782 if ( sscanf( client.lastStat, "%u %i %i %i", | |
783 &stat, &estimatedNumb, &first, &last ) != 4 ) | |
784 { | |
785 Log_err( "Bad server response to GROUP: %s", client.lastStat ); | |
786 return FALSE; | |
787 } | |
788 Utl_cpyStr( client.grp, name ); | |
789 client.rmtFirst = first; | |
790 client.rmtLast = last; | |
791 return TRUE; | |
792 } | |
793 | |
794 void | |
795 Client_rmtFirstLast( int *first, int *last ) | |
796 { | |
797 *first = client.rmtFirst; | |
798 *last = client.rmtLast; | |
799 } | |
800 | |
801 Bool | |
802 Client_postArt( const char *msgId, const char *artTxt, | |
803 Str errStr ) | |
804 { | |
805 if ( ! putCmd( "POST" ) ) | |
806 return FALSE; | |
807 if ( getStat() != STAT_SEND_ART ) | |
808 { | |
809 Log_err( "Posting of %s not allowed: %s", msgId, client.lastStat ); | |
810 strcpy( errStr, client.lastStat ); | |
811 return FALSE; | |
812 } | |
813 putTxtBuf( artTxt ); | |
814 putEndOfTxt(); | |
815 if ( getStat() != STAT_POST_OK ) | |
816 { | |
817 Log_err( "Posting of %s failed: %s", msgId, client.lastStat ); | |
818 strcpy( errStr, client.lastStat ); | |
819 return FALSE; | |
820 } | |
821 Log_inf( "Posted %s (Status: %s)", msgId, client.lastStat ); | |
822 return TRUE; | |
823 } |