1 /***************************************************************************
2 *
3 * $Header: /usr/local/cvsroot/utils/ytree/util.c,v 1.38 2019/09/29 10:37:49 werner Exp $
4 *
5 * Diverse Hilfsfunktionen
6 *
7 ***************************************************************************/
8
9
10 #include "ytree.h"
11 #include "xmalloc.h"
12
13
14 typedef struct
15 {
16 char *extension;
17 int method;
18 } Extension2Method;
19
20
21
22 static Extension2Method file_extensions[] = FILE_EXTENSIONS;
23 static char *GNU_getcwd(void);
24
25
GetPath(DirEntry * dir_entry,char * buffer)26 char *GetPath(DirEntry *dir_entry, char *buffer)
27 {
28 DirEntry *de_ptr;
29 char help_buffer[PATH_LENGTH + 1];
30
31 *buffer = '\0';
32
33 for( de_ptr = dir_entry; de_ptr; de_ptr = de_ptr->up_tree )
34 {
35 *help_buffer = '\0';
36 if( de_ptr->up_tree ) (void) strcat( help_buffer, FILE_SEPARATOR_STRING );
37 if( strcmp( de_ptr->name, FILE_SEPARATOR_STRING ) )
38 (void) strcat( help_buffer, de_ptr->name );
39 (void) strcat( help_buffer, buffer );
40 (void) strcpy( buffer, help_buffer );
41 }
42
43 /* if( *buffer == '\0' ) (void) strcpy( buffer, FILE_SEPARATOR_STRING ); */
44
45 return( buffer );
46 }
47
48
49
50
51
GetFileNamePath(FileEntry * file_entry,char * buffer)52 char *GetFileNamePath(FileEntry *file_entry, char *buffer)
53 {
54 (void) GetPath( file_entry->dir_entry, buffer );
55 if( *buffer && strcmp( buffer, FILE_SEPARATOR_STRING ) )
56 (void) strcat( buffer, FILE_SEPARATOR_STRING );
57 return( strcat( buffer, file_entry->name ) );
58 }
59
60
61
GetRealFileNamePath(FileEntry * file_entry,char * buffer)62 char *GetRealFileNamePath(FileEntry *file_entry, char *buffer)
63 {
64 char *sym_name;
65
66 if( mode == DISK_MODE || mode == USER_MODE )
67 return( GetFileNamePath( file_entry, buffer ) );
68
69 if( S_ISLNK( file_entry->stat_struct.st_mode ) )
70 {
71 sym_name = &file_entry->name[ strlen( file_entry->name ) + 1 ];
72 if( *sym_name == FILE_SEPARATOR_CHAR )
73 return( strcpy( buffer, sym_name ) );
74 }
75
76 (void) GetPath( file_entry->dir_entry, buffer );
77 if( *buffer && strcmp( buffer, FILE_SEPARATOR_STRING ) )
78 (void) strcat( buffer, FILE_SEPARATOR_STRING );
79 if( S_ISLNK( file_entry->stat_struct.st_mode ) )
80 return( strcat( buffer, &file_entry->name[ strlen( file_entry->name ) + 1 ] ) );
81 else
82 return( strcat( buffer, file_entry->name ) );
83 }
84
85
86
87
88
89
GetDirEntry(DirEntry * tree,DirEntry * current_dir_entry,char * dir_path,DirEntry ** dir_entry,char * to_path)90 int GetDirEntry(DirEntry *tree,
91 DirEntry *current_dir_entry,
92 char *dir_path,
93 DirEntry **dir_entry,
94 char *to_path
95 )
96 {
97 char dest_path[PATH_LENGTH+1];
98 char current_path[PATH_LENGTH+1];
99 char help_path[PATH_LENGTH+1];
100 char *token, *old;
101 DirEntry *de_ptr, *sde_ptr;
102 int n;
103
104 *dir_entry = NULL;
105 *to_path = '\0';
106
107 strcpy(to_path, dir_path);
108 if( Getcwd( current_path, sizeof( current_path ) - 2 ) == NULL )
109 {
110 (void) sprintf( message, "Getcwd failed*%s", strerror(errno) );
111 ERROR_MSG( message );
112 return( -1 );
113 }
114
115 if( *dir_path != FILE_SEPARATOR_CHAR )
116 {
117 if( chdir( GetPath( current_dir_entry, help_path ) ) )
118 {
119 ERROR_MSG( "Chdir Failed" );
120 return( -1 );
121 }
122 }
123
124 if( chdir( dir_path ) )
125 {
126 #ifdef DEBUG
127 (void) sprintf( message, "Invalid Path!*\"%s\"", dir_path );
128 MESSAGE( message );
129 #endif
130 return( -3 );
131 }
132
133 if( *dir_path != FILE_SEPARATOR_CHAR ) {
134 (void) Getcwd( dest_path, sizeof( dest_path ) - 2 );
135 (void) strcpy( to_path, dest_path );
136 } else {
137 strcpy(dest_path, dir_path);
138 }
139
140
141 if( chdir( current_path ) )
142 {
143 ERROR_MSG( "Chdir failed; Can't resume" );
144 return( -1 );
145 }
146
147 n = strlen( tree->name );
148 if( !strcmp(tree->name, FILE_SEPARATOR_STRING) ||
149 (!strncmp( tree->name, dest_path, n ) &&
150 ( dest_path[n] == FILE_SEPARATOR_CHAR || dest_path[n] == '\0' ) ) )
151 {
152 /* Pfad befindet sich im (Sub)-Tree */
153 /*----------------------------------*/
154
155 de_ptr = tree;
156 token = Strtok_r( &dest_path[n], FILE_SEPARATOR_STRING, &old );
157 while( token )
158 {
159 for( sde_ptr = de_ptr->sub_tree; sde_ptr; sde_ptr = sde_ptr->next )
160 {
161 if( !strcmp( sde_ptr->name, token ) )
162 {
163 /* Subtree gefunden */
164 /*------------------*/
165
166 de_ptr = sde_ptr;
167 break;
168 }
169 }
170 if( sde_ptr == NULL )
171 {
172 #ifdef DEBUG
173 (void) sprintf( message, "Can't find directory; token=%s", token );
174 ERROR_MSG( message );
175 #endif
176 return( -3 );
177 }
178 token = Strtok_r( NULL, FILE_SEPARATOR_STRING, &old );
179 }
180 *dir_entry = de_ptr;
181 }
182 return( 0 );
183 }
184
185
186
187
GetFileEntry(DirEntry * de_ptr,char * file_name,FileEntry ** file_entry)188 int GetFileEntry(DirEntry *de_ptr, char *file_name, FileEntry **file_entry)
189 {
190 FileEntry *fe_ptr;
191
192 *file_entry = NULL;
193
194 for( fe_ptr = de_ptr->file; fe_ptr; fe_ptr = fe_ptr->next )
195 {
196 if( !strcmp( fe_ptr->name, file_name ) )
197 {
198 /* Eintrag gefunden */
199 /*------------------*/
200
201 *file_entry = fe_ptr;
202 break;
203 }
204 }
205 return( 0 );
206 }
207
208
209
210
211
GetAttributes(unsigned short modus,char * buffer)212 char *GetAttributes(unsigned short modus, char *buffer)
213 {
214 char *save_buffer = buffer;
215
216 if( S_ISREG( modus ) ) *buffer++ = '-';
217 else if( S_ISDIR( modus ) ) *buffer++ = 'd';
218 else if( S_ISCHR( modus ) ) *buffer++ = 'c';
219 else if( S_ISBLK( modus ) ) *buffer++ = 'b';
220 else if( S_ISFIFO( modus ) ) *buffer++ = 'p';
221 else if( S_ISLNK( modus ) ) *buffer++ = 'l';
222 else if( S_ISSOCK( modus ) ) *buffer++ = 's'; /* ??? */
223 else *buffer++ = '?'; /* unknown */
224
225 if( modus & S_IRUSR ) *buffer++ = 'r';
226 else *buffer++ = '-';
227
228 if( modus & S_IWUSR ) *buffer++ = 'w';
229 else *buffer++ = '-';
230
231 if( modus & S_IXUSR ) *buffer++ = 'x';
232 else *buffer++ = '-';
233
234 if( modus & S_ISUID ) *(buffer - 1) = 's';
235
236
237 if( modus & S_IRGRP ) *buffer++ = 'r';
238 else *buffer++ = '-';
239
240 if( modus & S_IWGRP ) *buffer++ = 'w';
241 else *buffer++ = '-';
242
243 if( modus & S_IXGRP ) *buffer++ = 'x';
244 else *buffer++ = '-';
245
246 if( modus & S_ISGID ) *(buffer - 1) = 's';
247
248
249 if( modus & S_IROTH ) *buffer++ = 'r';
250 else *buffer++ = '-';
251
252 if( modus & S_IWOTH ) *buffer++ = 'w';
253 else *buffer++ = '-';
254
255 if( modus & S_IXOTH ) *buffer++ = 'x';
256 else *buffer++ = '-';
257
258 *buffer = '\0';
259
260 return( save_buffer );
261 }
262
263
264
CTime(time_t f_time,char * buffer)265 char *CTime(time_t f_time, char *buffer)
266 {
267 char *cptr;
268 time_t now;
269
270 if( (now = time( NULL )) == -1 )
271 {
272 ERROR_MSG( "time() failed" );
273 exit( 1 );
274 }
275
276 cptr = ctime( &f_time );
277 (void) strncpy( buffer, cptr+4, 12 );
278 buffer[12] = '\0';
279
280 if( (now - f_time) > 31536000L )
281 {
282 /* Differenz groesser als 1 Jahr */
283 /*-------------------------------*/
284
285 (void) strncpy( &buffer[7], cptr + 19, 5 );
286
287 }
288
289 return( buffer );
290 }
291
292
293
294
PrintSpecialString(WINDOW * win,int y,int x,char * str,int color)295 void PrintSpecialString(WINDOW *win, int y, int x, char *str, int color)
296 {
297 int ch;
298
299 if(x < 0 || y < 0) {
300 /* screen too small */
301 return;
302 }
303
304 wmove( win, y, x);
305
306 for( ; *str; str++ )
307 {
308 if ( (!iscntrl(*str)) || (!isspace(*str)) || (*str==' ') )
309 switch( *str )
310 {
311 case '1': ch = ACS_ULCORNER; break;
312 case '2': ch = ACS_URCORNER; break;
313 case '3': ch = ACS_LLCORNER; break;
314 case '4': ch = ACS_LRCORNER; break;
315 case '5': ch = ACS_TTEE; break;
316 case '6': ch = ACS_LTEE; break;
317 case '7': ch = ACS_RTEE; break;
318 case '8': ch = ACS_BTEE; break;
319 case '9': ch = ACS_LARROW; break;
320 case '|': ch = ACS_VLINE; break;
321 case '-': ch = ACS_HLINE; break;
322 default: ch = PRINT(*str);
323 }
324 else
325 ch = ACS_BLOCK;
326
327 #ifdef COLOR_SUPPORT
328 wattrset( win, COLOR_PAIR(color) | A_BOLD );
329 #endif /* COLOR_SUPPORT */
330 waddch( win, ch );
331 #ifdef COLOR_SUPPORT
332 wattrset( win, 0 );
333 #endif /* COLOR_SUPPORT */
334 }
335 }
336
337
Print(WINDOW * win,int y,int x,char * str,int color)338 void Print(WINDOW *win, int y, int x, char *str, int color)
339 {
340 int ch;
341
342 if(x < 0 || y < 0) {
343 /* screen too small */
344 return;
345 }
346 wmove(win, y, x);
347 for( ; *str; str++ )
348 {
349 ch = PRINT((int) *str);
350
351 #ifdef COLOR_SUPPORT
352 wattrset( win, COLOR_PAIR(color) | A_BOLD);
353 #endif /* COLOR_SUPPORT */
354 waddch(win, ch );
355 #ifdef COLOR_SUPPORT
356 wattrset( win, 0);
357 #endif /* COLOR_SUPPORT */
358 }
359 }
360
361
PrintOptions(WINDOW * win,int y,int x,char * str)362 void PrintOptions(WINDOW *win, int y, int x, char *str)
363 {
364 int ch;
365 int color, hi_color, lo_color;
366
367 if(x < 0 || y < 0) {
368 /* screen too small */
369 return;
370 }
371
372 #ifdef COLOR_SUPPORT
373 lo_color = MENU_COLOR;
374 hi_color = HIMENUS_COLOR;
375 #else
376 lo_color = A_NORMAL;
377 hi_color = A_BOLD;
378 #endif
379
380 color = lo_color;
381
382 for( ; *str; str++ )
383 {
384 ch = (int) *str;
385
386 switch( *str ) {
387 case '(': color = hi_color; continue;
388 case ')': color = lo_color; continue;
389
390 #ifdef COLOR_SUPPORT
391 case ']': color = lo_color; continue;
392 case '[': color = hi_color; continue;
393 #else
394 case ']':
395 case '[': /* ignore */ continue;
396 #endif
397
398 case '1': ch = ACS_ULCORNER; break;
399 case '2': ch = ACS_URCORNER; break;
400 case '3': ch = ACS_LLCORNER; break;
401 case '4': ch = ACS_LRCORNER; break;
402 case '5': ch = ACS_TTEE; break;
403 case '6': ch = ACS_LTEE; break;
404 case '7': ch = ACS_RTEE; break;
405 case '8': ch = ACS_BTEE; break;
406 case '9': ch = ACS_LARROW; break;
407 case '|': ch = ACS_VLINE; break;
408 case '-': ch = ACS_HLINE; break;
409 default: ch = PRINT(*str);
410 }
411
412 #ifdef COLOR_SUPPORT
413 wattrset( win, COLOR_PAIR(color) | A_BOLD);
414 #else
415 wattrset( win, color);
416 #endif
417 mvwaddch( win, y, x++, ch );
418 wattrset( win, 0 );
419 }
420 }
421
422
PrintMenuOptions(WINDOW * win,int y,int x,char * str,int ncolor,int hcolor)423 void PrintMenuOptions(WINDOW *win,int y, int x, char *str, int ncolor, int hcolor)
424 {
425 int ch;
426 int color, hi_color, lo_color;
427 char *sbuf, buf[2];
428
429 sbuf = (char *)malloc(strlen(str)+1);
430 sbuf[0] = '\0';
431 buf[1] = '\0';
432
433 if(x < 0 || y < 0) {
434 /* screen too small */
435 return;
436 }
437
438 #ifdef COLOR_SUPPORT
439 lo_color = MENU_COLOR;
440 hi_color = HIMENUS_COLOR;
441 #else
442 lo_color = A_NORMAL;
443 hi_color = A_REVERSE;
444 #endif
445
446 color = lo_color;
447 wmove(win, y, x);
448
449 for( ; *str; str++ )
450 {
451 ch = (int) *str;
452
453 switch( ch ) {
454 case '(': color = hi_color;
455 #ifdef COLOR_SUPPORT
456 WAttrAddStr( win, COLOR_PAIR(color) | A_BOLD, sbuf);
457 #else
458 WAttrAddStr( win, color, sbuf);
459 #endif
460 strcpy(sbuf, "");
461 continue;
462
463 case ')': color = lo_color;
464 #ifdef COLOR_SUPPORT
465 WAttrAddStr( win, COLOR_PAIR(color) | A_BOLD, sbuf);
466 #else
467 WAttrAddStr( win, color, sbuf);
468 #endif
469 strcpy(sbuf, "");
470 continue;
471
472 #ifdef COLOR_SUPPORT
473 case ']': color = lo_color;
474 WAttrAddStr( win, COLOR_PAIR(color) | A_BOLD, sbuf);
475 strcpy(sbuf, "");
476 continue;
477 case '[': color = hi_color;
478 WAttrAddStr( win, COLOR_PAIR(color) | A_BOLD, sbuf);
479 strcpy(sbuf, "");
480 continue;
481 #else
482 case ']':
483 case '[': /* ignore */ continue;
484 #endif
485 default : buf[0] = PRINT(*str);
486 strcat(sbuf, buf);
487 }
488 }
489
490 #ifdef COLOR_SUPPORT
491 WAttrAddStr( win, COLOR_PAIR(color) | A_BOLD, sbuf);
492 #else
493 WAttrAddStr( win, color, sbuf);
494 #endif
495 free(sbuf);
496 }
497
498
499 /*****************************************************************************
500 * FormFilename *
501 *****************************************************************************/
502
FormFilename(char * dest,char * src,unsigned int max_len)503 char *FormFilename(char *dest, char *src, unsigned int max_len)
504 {
505 int i;
506 int begin;
507 unsigned int l;
508
509 l = strlen(src);
510 begin = 0;
511
512 if( l <= max_len )
513 return( strcpy( dest, src ) );
514 else
515 {
516 for(i=0; i < (int) max_len - 4; i++)
517 if( src[l - i] == FILE_SEPARATOR_CHAR || src[l - i] == '\\' )
518 begin = l - i;
519 (void) strcpy( dest, "/..." );
520 return( strcat(dest, &src[begin] ) );
521 }
522 }
523
524
525 /*****************************************************************************
526 * CutFilename *
527 *****************************************************************************/
528
CutFilename(char * dest,char * src,unsigned int max_len)529 char *CutFilename(char *dest, char *src, unsigned int max_len)
530 {
531 unsigned int l;
532 char *tmp;
533
534 l = StrVisualLength(src);
535
536 if( l <= max_len )
537 return( strcpy( dest, src ) );
538 else
539 {
540 tmp = StrLeft(src, max_len - 3);
541 sprintf(dest, "%s...", tmp);
542 free(tmp);
543 return( dest );
544 }
545 }
546
547 /*****************************************************************************
548 * CutPathname *
549 *****************************************************************************/
550
CutPathname(char * dest,char * src,unsigned int max_len)551 char *CutPathname(char *dest, char *src, unsigned int max_len)
552 {
553 unsigned int l;
554
555 l = strlen(src);
556
557 if( l <= max_len )
558 return( strcpy( dest, src ) );
559 else
560 {
561 (void) strcpy( dest, "..." );
562 (void) strncat( dest, &src[l - max_len + 3], max_len - 3 );
563 return( dest );
564 }
565 }
566
567
568 /*****************************************************************************
569 * Fnsplit *
570 *****************************************************************************/
571
572 /* Aufsplitten des Dateinamens in die einzelnen Komponenten */
573
Fnsplit(char * path,char * dir,char * name)574 void Fnsplit(char *path, char *dir, char *name)
575 {
576 int i;
577 char *name_begin;
578 char *trunc_name;
579
580 while( *path == ' ' || *path == '\t' ) path++;
581
582 while( strchr(path, FILE_SEPARATOR_CHAR ) || strchr(path, '\\') )
583 *(dir++) = *(path++);
584
585 *dir = '\0';
586
587 name_begin = path;
588 trunc_name = name;
589
590 for(i=0; i < PATH_LENGTH && *path; i++ )
591 *(name++) = *(path++);
592
593 *name = '\0';
594
595 if( i == PATH_LENGTH && *path )
596 {
597 (void) sprintf( message, "filename too long:*%s*truncating to*%s",
598 name_begin, trunc_name
599 );
600 WARNING( message );
601 }
602 }
603
604
605
BuildFilename(char * in_filename,char * pattern,char * out_filename)606 int BuildFilename( char *in_filename,
607 char *pattern,
608 char *out_filename
609 )
610 {
611 char *cptr;
612 int result = 0;
613
614
615 for( ; *pattern; pattern++ )
616 {
617 if( *pattern == '*' )
618 {
619 cptr = in_filename;
620 for( ; (*out_filename = *cptr); out_filename++, cptr++ );
621 }
622 else
623 {
624 *out_filename++ = *pattern;
625 }
626 }
627
628 *out_filename = '\0';
629
630 return( result );
631 }
632
633
634
GetFileMethod(char * filename)635 int GetFileMethod( char *filename )
636 {
637 int i, k, l;
638
639 l = strlen( filename );
640
641 for( i=0;
642 i < (int)(sizeof( file_extensions ) / sizeof( file_extensions[0] ));
643 i++
644 )
645 {
646 k = strlen( file_extensions[i].extension );
647 if( l >= k && !strcmp( &filename[l-k], file_extensions[i].extension ) )
648 return( file_extensions[i].method );
649 }
650
651 return( NO_COMPRESS );
652 }
653
654
655
656 #ifdef __NeXT__
657
getcwd(char * dest,int len)658 char *getcwd(char *dest, int len)
659 {
660 static char buffer[MAXNAMLEN];
661 DIR *dirp;
662 struct direct *dp;
663 long inode;
664 char *cp = buffer + MAXNAMLEN - 1;
665
666 *cp = 0;
667
668 do {
669 dirp = opendir(".");
670 for (dp=readdir(dirp); dp; dp=readdir(dirp)) {
671 if(dp->d_namlen && !strcmp(dp->d_name,".")) {
672 break;
673 }
674 }
675 if (inode == dp->d_ino) break;
676 inode = dp->d_ino;
677 (void) closedir(dirp);
678 dirp = opendir("..");
679 for (dp=readdir(dirp); dp && (dp->d_ino != inode); dp=readdir(dirp));
680 cp -= dp->d_namlen;
681 (void) strncpy(cp,dp->d_name,dp->d_namlen);
682 *--cp = FILE_SEPARATOR_CHAR;
683 (void) closedir(dirp);
684 } while(!chdir(".."));
685
686 (void) chdir(cp+2);
687 (void) strncpy(dest,cp+2,len);
688 }
689
690
691 #endif
692
693
NormPath(char * in_path,char * out_path)694 void NormPath( char *in_path, char *out_path )
695 {
696 char *s, *d;
697 char *old, *opath;
698 int level;
699 char *in_path_dup;
700
701 level = 0;
702 opath = out_path;
703
704 if( ( in_path_dup = malloc( strlen( in_path ) + 1 ) ) == NULL ) {
705 ERROR_MSG( "Malloc Failed*ABORT" );
706 exit( 1 );
707 }
708
709 if( *in_path == FILE_SEPARATOR_CHAR ) {
710 s = in_path + 1;
711 *opath++ = FILE_SEPARATOR_CHAR;
712 } else {
713 s = in_path;
714 }
715
716 for( d=in_path_dup; *s; d++ ) {
717 *d = *s++;
718 while( *d == FILE_SEPARATOR_CHAR && *s == FILE_SEPARATOR_CHAR )
719 s++;
720 }
721 *d = '\0';
722
723 d = opath;
724 s = Strtok_r( in_path_dup, FILE_SEPARATOR_STRING, &old );
725 while( s ) {
726 if( strcmp( s, "." ) ) { /* skip "." */
727 if( !strcmp( s, ".." ) ) { /* optimize ".." */
728 if( level > 0 ) {
729 if( level == 1 ) {
730 d = out_path;
731 } else {
732 for( d -= 2; *d != FILE_SEPARATOR_CHAR; d-- )
733 ;
734 d++;
735 }
736 } else {
737 /* level <= 0 */
738 *d++ = '.';
739 *d++ = '.';
740 *d++ = FILE_SEPARATOR_CHAR;
741 }
742 level--;
743 } else { /* add component */
744 strcpy( d, s );
745 d += strlen( s );
746 *d++ = FILE_SEPARATOR_CHAR;
747 level++;
748 }
749 }
750 s = Strtok_r( NULL, FILE_SEPARATOR_STRING, &old );
751 }
752 if( level != 0 )
753 d--;
754 *d = '\0';
755 if( *out_path == '\0' )
756 strcpy(out_path, "." );
757
758 free( in_path_dup );
759 }
760
761
762
763 /* reentrantes strtok */
Strtok_r(char * str,char * delim,char ** old)764 char *Strtok_r( char *str, char *delim, char **old )
765 {
766 char *result;
767 int l, m;
768
769 if( str == NULL )
770 str = *old;
771
772 if( str == NULL )
773 return( NULL );
774
775 l = strlen( str );
776 if( ( result = strtok( str, delim ) ) != NULL ) {
777 m = strlen( result );
778 if( (m + 1) >= l)
779 *old = NULL;
780 else
781 *old = result + m + 1;
782
783 } else
784 *old = NULL;
785
786 return( result );
787 }
788
789
790
791
GetMaxYX(WINDOW * win,int * height,int * width)792 void GetMaxYX(WINDOW *win, int *height, int *width)
793 {
794 if( win == dir_window )
795 {
796 *height = MAXIMUM(DIR_WINDOW_HEIGHT, 1);
797 *width = MAXIMUM(DIR_WINDOW_WIDTH, 1);
798 }
799 else if( win == small_file_window )
800 {
801 *height = MAXIMUM(FILE_WINDOW_1_HEIGHT, 1);
802 *width = MAXIMUM(FILE_WINDOW_1_WIDTH, 1);
803 }
804 else if( win == big_file_window )
805 {
806 *height = MAXIMUM(FILE_WINDOW_2_HEIGHT, 1);
807 *width = MAXIMUM(FILE_WINDOW_2_WIDTH, 1);
808 }
809 else if( win == f2_window )
810 {
811 *height = MAXIMUM(F2_WINDOW_HEIGHT - 1, 1); /* fake for separator line */
812 *width = MAXIMUM(F2_WINDOW_WIDTH, 1);
813 }
814 else if( win == history_window )
815 {
816 *height = MAXIMUM(HISTORY_WINDOW_HEIGHT, 1);
817 *width = MAXIMUM(HISTORY_WINDOW_WIDTH, 1);
818 }
819 else
820 {
821 ERROR_MSG( "Unknown Window-ID*ABORT" );
822 exit( 1 );
823 }
824 }
825
826
Strrcmp(char * s1,char * s2)827 int Strrcmp(char *s1, char* s2)/*compares in reverse order 2 strings*/
828 {
829 int aux;
830 int l1 = strlen(s1);
831 int l2 = strlen(s2);
832
833 for (aux = 0; aux <= l2; aux++)
834 {
835 if ((l1 - aux) < 0)
836 return(-1);
837 if (s1[l1 - aux] > s2[l2 - aux])
838 return(1);
839 else if (s1[l1 - aux] < s2[l2 - aux])
840 return(-1);
841 }
842 return(0);
843 }
844
845
846
847 /* NeXT does not define strdup */
Strdup(const char * s)848 char *Strdup(const char *s)
849 {
850 char *cp = NULL;
851
852 if (s) {
853 cp = malloc(strlen(s)+1);
854 if (cp) {
855 strcpy(cp,s);
856 }
857 }
858 return(cp);
859 }
860
861 /* Solaris does not define this */
Strndup(const char * s,int len)862 char *Strndup(const char *s, int len)
863 {
864 char *cp = NULL;
865 int l;
866
867 if (s) {
868 l = MINIMUM(strlen(s), len);
869 cp = malloc(l+1);
870 if (cp) {
871 memcpy(cp, s, l);
872 cp[l] = '\0';
873 }
874 }
875 return(cp);
876 }
877
878
GetExtension(char * filename)879 char *GetExtension(char *filename)
880 {
881 char *cptr;
882
883 cptr = strrchr(filename, '.');
884
885 if(cptr == NULL) return "";
886
887 if(cptr == filename) return "";
888 // filenames beginning with a dot are not an extension
889
890 return(cptr + 1);
891 }
892
893
894
895
StrCp(char * dest,const char * src)896 void StrCp(char *dest, const char *src)
897 {
898 static char esc_chars[] ="#*|&;()<> \t\n\r\"!$?'`~";
899
900 while(*src)
901 {
902 if(strchr(esc_chars, *src))
903 *dest++ = '\\';
904 *dest++ = *src++;
905 }
906 *dest = '\0';
907 }
908
909
910
911
BuildUserFileEntry(FileEntry * fe_ptr,int max_filename_len,int max_linkname_len,char * template,int linelen,char * line)912 int BuildUserFileEntry(FileEntry *fe_ptr,
913 int max_filename_len, int max_linkname_len,
914 char *template, int linelen, char *line)
915 {
916 char attributes[11];
917 char modify_time[13];
918 char change_time[13];
919 char access_time[13];
920 char format1[60];
921 char format2[60];
922 int n;
923 char owner[OWNER_NAME_MAX + 1];
924 char group[GROUP_NAME_MAX + 1];
925 char *owner_name_ptr;
926 char *group_name_ptr;
927 char *sym_link_name = NULL;
928 char *sptr, *dptr;
929 char tag;
930 char buffer[4096]; /* enough??? */
931
932
933 if( fe_ptr && S_ISLNK( fe_ptr->stat_struct.st_mode ) )
934 sym_link_name = &fe_ptr->name[strlen(fe_ptr->name)+1];
935 else
936 sym_link_name = "";
937
938
939 tag = (fe_ptr->tagged) ? TAGGED_SYMBOL : ' ';
940 (void) GetAttributes( fe_ptr->stat_struct.st_mode, attributes);
941
942 (void) CTime( fe_ptr->stat_struct.st_mtime, modify_time );
943 (void) CTime( fe_ptr->stat_struct.st_ctime, change_time );
944 (void) CTime( fe_ptr->stat_struct.st_atime, access_time );
945
946 owner_name_ptr = GetPasswdName(fe_ptr->stat_struct.st_uid);
947 group_name_ptr = GetGroupName(fe_ptr->stat_struct.st_gid);
948
949 if( owner_name_ptr == NULL )
950 {
951 (void) sprintf( owner, "%d", (int) fe_ptr->stat_struct.st_uid );
952 owner_name_ptr = owner;
953 }
954 if( group_name_ptr == NULL )
955 {
956 (void) sprintf( group, "%d", (int) fe_ptr->stat_struct.st_gid );
957 group_name_ptr = group;
958 }
959
960
961 sprintf(format1, "%%-%ds", max_filename_len);
962 sprintf(format2, "%%-%ds", max_linkname_len);
963
964 for(sptr=template, dptr=buffer; *sptr; ) {
965
966 if(*sptr == '%') {
967 sptr++;
968 if(!strncmp(sptr, TAGSYMBOL_VIEWNAME, 3)) {
969 *dptr = tag; n=1;
970 } else if(!strncmp(sptr, FILENAME_VIEWNAME, 3)) {
971 n = sprintf(dptr, format1, fe_ptr->name);
972 } else if(!strncmp(sptr, ATTRIBUTE_VIEWNAME, 3)) {
973 n = sprintf(dptr, "%10s", attributes);
974 } else if(!strncmp(sptr, LINKCOUNT_VIEWNAME, 3)) {
975 n = sprintf(dptr, "%3d", (int)fe_ptr->stat_struct.st_nlink);
976 } else if(!strncmp(sptr, FILESIZE_VIEWNAME, 3)) {
977 #ifdef HAS_LONGLONG
978 n = sprintf(dptr, "%7lld", (LONGLONG) fe_ptr->stat_struct.st_size);
979 #else
980 n = sprintf(dptr, "%7d", fe_ptr->stat_struct.st_size);
981 #endif
982 } else if(!strncmp(sptr, MODTIME_VIEWNAME, 3)) {
983 n = sprintf(dptr, "%12s", modify_time);
984 } else if(!strncmp(sptr, SYMLINK_VIEWNAME, 3)) {
985 n = sprintf(dptr, format2, sym_link_name);
986 } else if(!strncmp(sptr, UID_VIEWNAME, 3)) {
987 n = sprintf(dptr, "%-8s", owner_name_ptr);
988 } else if(!strncmp(sptr, GID_VIEWNAME, 3)) {
989 n = sprintf(dptr, "%-8s", group_name_ptr);
990 } else if(!strncmp(sptr, INODE_VIEWNAME, 3)) {
991 #ifdef HAS_LONGLONG
992 n = sprintf(dptr, "%7lld", (LONGLONG)fe_ptr->stat_struct.st_ino);
993 #else
994 n = sprintf(dptr, "%7ld", (int)fe_ptr->stat_struct.st_ino);
995 #endif
996 } else if(!strncmp(sptr, ACCTIME_VIEWNAME, 3)) {
997 n = sprintf(dptr, "%12s", access_time);
998 } else if(!strncmp(sptr, CHGTIME_VIEWNAME, 3)) {
999 n = sprintf(dptr, "%12s", change_time);
1000 } else {
1001 n = -1;
1002 }
1003 if(n == -1) {
1004 *dptr++ = '%';
1005 } else {
1006 dptr += n;
1007 if(*sptr) sptr++;
1008 if(*sptr) sptr++;
1009 if(*sptr) sptr++;
1010 }
1011 } else {
1012 *dptr++ = *sptr++;
1013 }
1014 }
1015 *dptr = '\0';
1016 strncpy(line, buffer, linelen);
1017 line[linelen - 1] = '\0';
1018 return(0);
1019 }
1020
1021
1022
GetUserFileEntryLength(int max_filename_len,int max_linkname_len,char * template)1023 int GetUserFileEntryLength( int max_filename_len, int max_linkname_len, char *template)
1024 {
1025 int len, n;
1026 char *sptr;
1027
1028
1029 for(len=0, sptr=template; *sptr; ) {
1030
1031 if(*sptr == '%') {
1032 sptr++;
1033 if(!strncmp(sptr, TAGSYMBOL_VIEWNAME, 3)) {
1034 n=1;
1035 } else if(!strncmp(sptr, FILENAME_VIEWNAME, 3)) {
1036 n = max_filename_len;
1037 } else if(!strncmp(sptr, ATTRIBUTE_VIEWNAME, 3)) {
1038 n = 10;
1039 } else if(!strncmp(sptr, LINKCOUNT_VIEWNAME, 3)) {
1040 n = 3;
1041 } else if(!strncmp(sptr, FILESIZE_VIEWNAME, 3)) {
1042 n = 7;
1043 } else if(!strncmp(sptr, MODTIME_VIEWNAME, 3)) {
1044 n = 12;
1045 } else if(!strncmp(sptr, SYMLINK_VIEWNAME, 3)) {
1046 n = max_linkname_len;
1047 } else if(!strncmp(sptr, UID_VIEWNAME, 3)) {
1048 n = 8;
1049 } else if(!strncmp(sptr, GID_VIEWNAME, 3)) {
1050 n = 8;
1051 } else if(!strncmp(sptr, INODE_VIEWNAME, 3)) {
1052 n = 7;
1053 } else if(!strncmp(sptr, ACCTIME_VIEWNAME, 3)) {
1054 n = 12;
1055 } else if(!strncmp(sptr, CHGTIME_VIEWNAME, 3)) {
1056 n = 12;
1057 } else {
1058 n = -1;
1059 }
1060 if(n == -1) {
1061 len++;
1062 sptr++;
1063 } else {
1064 len += n;
1065 if(*sptr) sptr++;
1066 if(*sptr) sptr++;
1067 if(*sptr) sptr++;
1068 }
1069 } else {
1070 sptr++;
1071 len++;
1072 }
1073 }
1074 return(len);
1075 }
1076
1077
AtoLL(char * cptr)1078 LONGLONG AtoLL(char *cptr)
1079 {
1080 LONGLONG ll;
1081
1082 #ifdef HAS_LONGLONG
1083
1084 sscanf(cptr, "%lld", &ll);
1085
1086 #else
1087 #ifdef __QNX__
1088 sscanf(cptr, "%ld", &ll);
1089 #else
1090 sscanf(ll, "%ld", cptr);
1091 #endif
1092 #endif
1093
1094 return(ll);
1095 }
1096
1097
1098
1099
1100 #ifndef HAVE_STRERROR
StrError(int errnum)1101 const char *StrError(int errnum)
1102 {
1103
1104 #if !defined(__FreeBSD__) && !(defined(__GLIBC__) && __GLIBC__ >= 2)
1105 extern char *sys_errlist[];
1106 extern int sys_nerr;
1107 #endif
1108
1109 if (errnum > 0 && errnum <= sys_nerr)
1110 return(sys_errlist[errnum]);
1111 return ("Unknown system error");
1112 }
1113 #endif /* HAVE_STRERROR */
1114
1115
1116 /*****************************************************************************
1117 * Getcwd *
1118 *****************************************************************************/
1119
1120
Getcwd(char * buffer,unsigned int size)1121 char *Getcwd(char *buffer, unsigned int size)
1122 {
1123 if(size == 0)
1124 return(GNU_getcwd());
1125
1126 return(getcwd(buffer, size));
1127 }
1128
1129
GNU_getcwd()1130 static char *GNU_getcwd()
1131 {
1132 unsigned int size = 100;
1133
1134 while (1)
1135 {
1136 char *buffer = (char *) xmalloc (size);
1137 if (getcwd (buffer, size) == buffer)
1138 return buffer;
1139 free (buffer);
1140 if (errno != ERANGE)
1141 return 0;
1142 size *= 2;
1143 }
1144 }
1145
1146 /*****************************************************************************
1147 * CutName *
1148 *****************************************************************************/
1149
CutName(char * dest,char * src,unsigned int max_len)1150 char *CutName(char *dest, char *src, unsigned int max_len)
1151 {
1152 unsigned int l;
1153
1154 l = strlen(src);
1155
1156 if( l <= max_len )
1157 return( strcpy( dest, src ) );
1158 else
1159 {
1160 (void) strncpy( dest, src, max_len - 3 );
1161 return strcpy( &dest[max_len - 3], "..." );
1162 }
1163 }
1164
1165
1166
1167