+/*
+ * $Id: asingle.c,v 1.14 2010-01-27 21:27:53 didg Exp $
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif /* HAVE_CONFIG_H */
+
#include <sys/types.h>
#include <sys/uio.h>
#include <sys/time.h>
#include <sys/param.h>
+#ifdef HAVE_FCNTL_H
#include <fcntl.h>
+#endif /* HAVE_FCNTL_H */
+#include <time.h>
#include <string.h>
-#include <syslog.h>
#include <ctype.h>
#include <stdio.h>
+#ifdef HAVE_UNISTD_H
#include <unistd.h>
+#endif /* HAVE_UNISTD_H */
#include <atalk/adouble.h>
#include <netatalk/endian.h>
+#include "asingle.h"
#include "megatron.h"
-#define DEBUG 0
-
/* String used to indicate standard input instead of a disk
file. Should be a string not normally used for a file
*/
following globals; therefore this module can only be used
for one of the two functions at a time.
*/
-struct single_file_data {
+static struct single_file_data {
int filed;
char path[ MAXPATHLEN + 1];
struct ad_entry entry[ ADEID_MAX ];
} single;
extern char *forkname[];
-u_char header_buf[ AD_HEADER_LEN ];
+static u_char header_buf[ AD_HEADER_LEN ];
/*
* single_open must be called first. pass it a filename that is supposed
* somewhat initialized; single_filed is set.
*/
-single_open( singlefile, flags, fh, options )
- char *singlefile;
- int flags, options;
- struct FHeader *fh;
+int single_open(char *singlefile, int flags, struct FHeader *fh, int options _U_)
{
int rc;
strncpy( single.path, singlefile, MAXPATHLEN );
#if DEBUG
fprintf( stderr, "opened %s for read\n", single.path );
-#endif
+#endif /* DEBUG */
if ((( rc = single_header_test()) > 0 ) &&
( single_header_read( fh, rc ) == 0 )) {
return( 0 );
single_close( KEEP );
return( -1 );
}
+ return( 0 );
}
/*
* Otherwise, a value of -1 is returned.
*/
-single_close( keepflag )
- int keepflag;
+int single_close( int keepflag)
{
if ( keepflag == KEEP ) {
return( close( single.filed ));
* bytes of the other two forks can be read, as well.
*/
-single_header_read( fh, version )
- struct FHeader *fh;
- int version;
+int single_header_read( struct FHeader *fh, int version)
{
/*
* entry_buf is used for reading in entry descriptors, and for reading in
u_short num_entries;
int n;
int readlen;
- int date_entry;
+ int date_entry = 0;
off_t pos;
/*
num_entries = ntohs( num_entries );
#if DEBUG >= 2
fprintf( stderr, "The number of entries is %d\n", num_entries );
-#endif
+#endif /* DEBUG */
for ( ; num_entries > 0 ; num_entries-- ) {
if ( read( single.filed, (char *)entry_buf, AD_ENTRY_LEN )
!= AD_ENTRY_LEN ) {
fprintf( stderr, "entry_id\t%d\n", entry_id );
fprintf( stderr, "\toffset\t\t%d\n", single.entry[ entry_id ].ade_off );
fprintf( stderr, "\tlength\t\t%d\n", single.entry[ entry_id ].ade_len );
-#endif
+#endif /* DEBUG */
}
/*
*/
if ( version == 1 ) {
- if ( single.entry[ ADEID_FILEI ].ade_len > 0 ) {
+ if ( single.entry[ ADEID_FILEI ].ade_len > 0 )
date_entry = ADEID_FILEI;
- } else {
- date_entry = 0;
- }
} else if ( version == 2 ) {
- if ( single.entry[ ADEID_FILEDATESI ].ade_len > 0 ) {
+ if ( single.entry[ ADEID_FILEDATESI ].ade_len > 0 )
date_entry = ADEID_FILEDATESI;
- } else {
- date_entry = 0;
- }
}
#if DEBUG
fprintf( stderr, "date_entry = %d\n", date_entry );
-#endif
+#endif /* DEBUG */
/*
* Go through and copy all the information you can get from
type[4] = creator[4] = '\0';
fprintf( stderr, "type is %s, creator is %s\n", type, creator );
}
-#endif
+#endif /* DEBUG */
}
if (( single.entry[ ADEID_COMMENT ].ade_len == 0 ) ||
( single.entry[ ADEID_COMMENT ].ade_off <= AD_HEADER_LEN )) {
* Unless I can't get the current date, in which case use time zero.
*/
if (( date_entry < 7 ) || ( date_entry > 8 )) {
- if (( time_seconds = time( NULL )) == -1 ) {
+ if (( time_seconds = time( NULL )) == (u_int32_t)-1 ) {
time_seconds = AD_DATE_START;
} else {
time_seconds = AD_DATE_FROM_UNIX(time_seconds);
sizeof(fh->backup_date));
}
if ( single.entry[ ADEID_RFORK ].ade_off == 0 ) {
- fh->forklen[ ADEID_RFORK ] = 0;
+ fh->forklen[RESOURCE] = 0;
} else {
- fh->forklen[ ADEID_RFORK ] =
+ fh->forklen[RESOURCE] =
htonl( single.entry[ ADEID_RFORK ].ade_len );
}
if ( single.entry[ ADEID_DFORK ].ade_off == 0 ) {
* "Macintosh " (that is seven blanks of padding).
*/
#define MACINTOSH "Macintosh "
-u_char sixteennulls[] = { 0, 0, 0, 0, 0, 0, 0, 0,
+static u_char sixteennulls[] = { 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0 };
-single_header_test()
+int single_header_test(void)
{
- int cc;
+ ssize_t cc;
u_int32_t templong;
cc = read( single.filed, (char *)header_buf, sizeof( header_buf ));
- if ( cc < sizeof( header_buf )) {
+ if ( cc < (ssize_t)sizeof( header_buf )) {
perror( "Premature end of file :" );
return( -1 );
}
*
*/
-single_read( fork, buffer, length )
- int fork;
- char *buffer;
- int length;
+ssize_t single_read( int fork, char *buffer, size_t length)
{
u_int32_t entry_id;
char *buf_ptr;
- int readlen;
- int cc = 1;
+ size_t readlen;
+ ssize_t cc = 1;
off_t pos;
switch ( fork ) {
break;
}
- if ( single.entry[ entry_id ].ade_len < 0 ) {
- fprintf( stderr, "single_read: Trying to read past end of fork!\n" );
- return( single.entry[ entry_id ].ade_len );
+ if (single.entry[entry_id].ade_len > 0x7FFFFFFF) {
+ fprintf(stderr, "single_read: Trying to read past end of fork!, ade_len == %u\n", single.entry[entry_id].ade_len);
+ return -1;
}
if ( single.entry[ entry_id ].ade_len == 0 ) {
if ( fork == DATA ) {
projects / netatalk.git / blobdiff