Community Company Search Contact

utils.c from EmStar at Krugle

Show utils.c syntax highlighted

////////////////////////////////////////////////////////////////////////////
//                           **** WAVPACK ****                            //
//                  Hybrid Lossless Wavefile Compressor                   //
//              Copyright (c) 1998 - 2005 Conifer Software.               //
//                          All Rights Reserved.                          //
//      Distributed under the BSD Software License (see license.txt)      //
////////////////////////////////////////////////////////////////////////////

// utils.c

// This module provides general purpose utilities for the WavPack command-line
// utilities and the self-extraction module.

#if defined(WIN32)
#include <windows.h>
#include <io.h>
#include <conio.h>
#include <shlobj.h>
#elif defined(__GNUC__)
#include <glob.h>
#endif

#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>

#include "wavpack.h"


#ifdef WIN32

int copy_timestamp (const char *src_filename, const char *dst_filename)
{
    FILETIME last_modified;
    HANDLE src, dst;
    int res = TRUE;

    if (*src_filename == '-' || *dst_filename == '-')
	return res;

    src = CreateFile (src_filename, GENERIC_READ, FILE_SHARE_READ, NULL,
	 OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);

    dst = CreateFile (dst_filename, GENERIC_WRITE, FILE_SHARE_WRITE, NULL,
	 OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
	
    if (src == INVALID_HANDLE_VALUE || dst == INVALID_HANDLE_VALUE ||
	!GetFileTime (src, NULL, NULL, &last_modified) ||
	!SetFileTime (dst, NULL, NULL, &last_modified))
	    res = FALSE;

    if (src != INVALID_HANDLE_VALUE)
	CloseHandle (src);

    if (dst != INVALID_HANDLE_VALUE)
	CloseHandle (dst);

    return res;
}

#else

#include <sys/time.h>
#include <sys/types.h>

int copy_timestamp(const char *src_filename, const char *dst_filename)
{
    struct stat fileinfo;
    struct timeval times[2];

    if (strcmp(src_filename, "-") == 0 || strcmp(dst_filename, "-") == 0)
        return TRUE;

    if (stat(src_filename, &fileinfo))
        return FALSE; /* stat failed */

    times[0].tv_sec  = fileinfo.st_atime;
    times[0].tv_usec = 0;

    times[1].tv_sec  = fileinfo.st_mtime;
    times[1].tv_usec = 0;

    if (utimes(dst_filename, times))
        return FALSE; /* utimes failed */

    return TRUE;
}

#endif

//////////////////////////////////////////////////////////////////////////////
// This function parses a filename (with or without full path) and returns  //
// a pointer to the extension (including the "."). If no extension is found //
// then NULL is returned. Extensions with more than 3 letters don't count.  //
//////////////////////////////////////////////////////////////////////////////

#if defined(WIN32)

static int is_second_byte (char *filespec, char *pos);

char *filespec_ext (char *filespec)
{
    char *cp = filespec + strlen (filespec);
    LANGID langid = GetSystemDefaultLangID ();

    while (--cp >= filespec) {

	if (langid == 0x411 && is_second_byte (filespec, cp))
	    --cp;

	if (*cp == '\\' || *cp == ':')
	    return NULL;

	if (*cp == '.') {
	    if (strlen (cp) > 1 && strlen (cp) <= 4)
		return cp;
	    else
		return NULL;
	}
    }

    return NULL;
}

#else

char *filespec_ext (char *filespec)
{
    char *cp = filespec + strlen (filespec);

    while (--cp >= filespec) {

	if (*cp == '/' || *cp == ':')
	    return NULL;

	if (*cp == '.') {
	    if (strlen (cp) > 1 && strlen (cp) <= 4)
		return cp;
	    else
		return NULL;
	}
    }

    return NULL;
}

#endif

//////////////////////////////////////////////////////////////////////////////
// This function determines if the specified filespec is a valid pathname.  //
// If not, NULL is returned. If it is in the format of a pathname, then the //
// original pointer is returned. If the format is ambiguous, then a lookup  //
// is performed to determine if it is in fact a valid path, and if so a "\" //
// is appended so that the pathname can be used and the original pointer is //
// returned.                                                                //
//////////////////////////////////////////////////////////////////////////////

#if defined(__GNUC__) && !defined(WIN32)

char *filespec_path (char *filespec)
{
    char *cp = filespec + strlen (filespec);
    glob_t globs;
    struct stat fstats;

    if (cp == filespec || filespec_wild (filespec))
	return NULL;

    if (*--cp == '/' || *cp == ':')
	return filespec;

    if (*cp == '.' && cp == filespec)
	return strcat (filespec, "/");

    if (glob (filespec, GLOB_MARK|GLOB_NOSORT, NULL, &globs) == 0 &&
	globs.gl_pathc > 0)
    {
	/* test if the file is a directory */
	if (stat(globs.gl_pathv[0], &fstats) == 0 && (fstats.st_mode & S_IFDIR)) {
		filespec[0] = '\0';
		strcat (filespec, globs.gl_pathv[0]);
		globfree(&globs);
		return filespec;
	}
    }
    globfree(&globs);

    return NULL;
}

#else

char *filespec_path (char *filespec)
{
    char *cp = filespec + strlen (filespec);
    LANGID langid = GetSystemDefaultLangID ();
    struct _finddata_t finddata;
    int32_t file;

    if (cp == filespec || filespec_wild (filespec))
	return NULL;

    --cp;

    if (langid == 0x411 && is_second_byte (filespec, cp))
	--cp;

    if (*cp == '\\' || *cp == ':')
	return filespec;

    if (*cp == '.' && cp == filespec)
	return strcat (filespec, "\\");

    if ((file = _findfirst (filespec, &finddata)) != -1L &&
	(finddata.attrib & _A_SUBDIR)) {
	    _findclose (file);
	    return strcat (filespec, "\\");
    }
    if (file != -1L)
	    _findclose(file);
    
    return NULL;
}

#endif

//////////////////////////////////////////////////////////////////////////////
// This function returns non-NULL if the specified filename spec has any    //
// wildcard characters.                                                     //
//////////////////////////////////////////////////////////////////////////////

char *filespec_wild (char *filespec)
{
    return strpbrk (filespec, "*?");
}

//////////////////////////////////////////////////////////////////////////////
// This function parses a filename (with or without full path) and returns  //
// a pointer to the actual filename, or NULL if no filename can be found.   //
//////////////////////////////////////////////////////////////////////////////

#if defined(WIN32)

char *filespec_name (char *filespec)
{
    char *cp = filespec + strlen (filespec);
    LANGID langid = GetSystemDefaultLangID ();

    while (--cp >= filespec) {
	if (langid == 0x411 && is_second_byte (filespec, cp))
	    --cp;

	if (*cp == '\\' || *cp == ':')
	    break;
    }

    if (strlen (cp + 1))
	return cp + 1;
    else
	return NULL;
}

#else

char *filespec_name (char *filespec)
{
    char *cp = filespec + strlen (filespec);

    while (--cp >= filespec)
	if (*cp == '/' || *cp == ':')
	    break;

    if (strlen (cp + 1))
	return cp + 1;
    else
	return NULL;
}

#endif

//////////////////////////////////////////////////////////////////////////////
// This function returns TRUE if "pos" is pointing to the second byte of a  //
// double-byte character in the string "filespec" which is assumed to be    //
// shift-JIS.                                                               //
//////////////////////////////////////////////////////////////////////////////

#if defined(WIN32)

static int is_second_byte (char *filespec, char *pos)
{
    uchar *cp = pos;

    while (cp > filespec && ((cp [-1] >= 0x81 && cp [-1] <= 0x9f) ||
                             (cp [-1] >= 0xe0 && cp [-1] <= 0xfc)))
	cp--;

    return ((int) pos - (int) cp) & 1;
}

#endif

//////////////////////////////////////////////////////////////////////////////
// This function allows the user to type 'y', 'n', or 'a' (with Enter) in   //
// response to a system query. The return value is the key typed as         //
// lowercase (regardless of the typed case).                                //
//////////////////////////////////////////////////////////////////////////////

static int waiting_input;

char yna (void)
{
    char choice = 0;
    int key;

    waiting_input = 1;

    while (1) {
#if defined(WIN32)
	key = getch ();
#else
	key = fgetc(stdin);
#endif
	if (key == 3) {
	    fprintf (stderr, "^C\n");
	    exit (1);
	}
	else if (key == '\r' || key == '\n') {
	    if (choice) {
		fprintf (stderr, "\r\n");
		break;
	    }
	    else
		fprintf (stderr, "%c", 7);
	}
	else if (key == 'Y' || key == 'y') {
	    fprintf (stderr, "%c\b", key);
	    choice = 'y';
	}
	else if (key == 'N' || key == 'n') {
	    fprintf (stderr, "%c\b", key);
	    choice = 'n';
	}
	else if (key == 'A' || key == 'a') {
	    fprintf (stderr, "%c\b", key);
	    choice = 'a';
	}
	else
	    fprintf (stderr, "%c", 7);
    }

    waiting_input = 0;

    return choice;
}

//////////////////////////////////////////////////////////////////////////////
// Display the specified message on the console through stderr. Note that   //
// the cursor may start anywhere in the line and all text already on the    //
// line is erased. A terminating newline is not needed and function works   //
// with printf strings and args.                                            //
//////////////////////////////////////////////////////////////////////////////

extern int debug_logging_mode;

#ifdef WIN32

int get_app_path (char *app_path)
{
    static char file_path [MAX_PATH], tried, result;

    HINSTANCE hinstLib;
    FARPROC ProcAdd;

    if (tried) {
	if (result)
	    strcpy (app_path, file_path);

	return result;
    }

    tried = TRUE;
    hinstLib = LoadLibrary ("shell32.dll");

    if (hinstLib) {
	ProcAdd = GetProcAddress (hinstLib, "SHGetFolderPathA");

	if (ProcAdd && SUCCEEDED ((ProcAdd) (NULL, CSIDL_APPDATA | 0x8000, NULL, 0, file_path)))
	    result = TRUE;

	if (!result) {
	    ProcAdd = GetProcAddress (hinstLib, "SHGetSpecialFolderPathA");

	    if (ProcAdd && SUCCEEDED ((ProcAdd) (NULL, file_path, CSIDL_APPDATA, TRUE)))
		result = TRUE;
	}

	FreeLibrary (hinstLib);
    }

    if (!result) {
	hinstLib = LoadLibrary ("shfolder.dll");

	if (hinstLib) {
	    ProcAdd = GetProcAddress (hinstLib, "SHGetFolderPathA");

	    if (ProcAdd && SUCCEEDED ((ProcAdd) (NULL, CSIDL_APPDATA | 0x8000, NULL, 0, file_path)))
		result = TRUE;

	    FreeLibrary (hinstLib);
	}
    }

    if (result)
	strcpy (app_path, file_path);

    return result;
}

void error_line (char *error, ...)
{
    char error_msg [512];
    va_list argptr;

    error_msg [0] = '\r';
    va_start (argptr, error);
    vsprintf (error_msg + 1, error, argptr);
    va_end (argptr);
    fputs (error_msg, stderr);
    finish_line ();

    if (debug_logging_mode) {
	char file_path [MAX_PATH];
	FILE *error_log = NULL;

	if (get_app_path (file_path)) {
	    strcat (file_path, "\\WavPack\\wavpack.log");
	    error_log = fopen (file_path, "a+");

	    if (!error_log) {
		get_app_path (file_path);
		strcat (file_path, "\\WavPack");

		if (CreateDirectory (file_path, NULL)) {
		    strcat (file_path, "\\wavpack.log");
		    error_log = fopen (file_path, "a+");
		}
	    }
	}

	if (!error_log)
	    error_log = fopen ("c:\\wavpack.log", "a+");

	if (error_log) {
	    fputs (error_msg + 1, error_log);
	    fputc ('\n', error_log);
	    fclose (error_log);
	}
    }
}

#else

void error_line (char *error, ...)
{
    char error_msg [512];
    va_list argptr;

    error_msg [0] = '\r';
    va_start (argptr, error);
    vsprintf (error_msg + 1, error, argptr);
    va_end (argptr);
    fputs (error_msg, stderr);
    finish_line ();
}

#endif

void debug_line (char *error, ...)
{
    char error_msg [512];
    va_list argptr;

    if (!debug_logging_mode)
	return;

    error_msg [0] = '\r';
    va_start (argptr, error);
    vsprintf (error_msg + 1, error, argptr);
    va_end (argptr);
    fputs (error_msg, stderr);
    finish_line ();

    if (debug_logging_mode) {
	FILE *error_log = fopen ("c:\\wavpack.log", "a+");

	if (error_log) {
	    fputs (error_msg + 1, error_log);
	    fputc ('\n', error_log);
	    fclose (error_log);
	}
    }
}

//////////////////////////////////////////////////////////////////////////////
// Function to intercept ^C or ^Break typed at the console.                 //
//////////////////////////////////////////////////////////////////////////////
#if defined(WIN32)
static int break_flag;

BOOL WINAPI ctrl_handler (DWORD ctrl)
{
    if (ctrl == CTRL_C_EVENT) {
	break_flag = TRUE;
	return TRUE;
    }

    if (ctrl == CTRL_BREAK_EVENT) {

	if (waiting_input) {
	    return FALSE;
	}
	else {
	    break_flag = TRUE;
	    return TRUE;
	}
    }

    return FALSE;
}

//////////////////////////////////////////////////////////////////////////////
// Function to initialize console for intercepting ^C and ^Break.           //
//////////////////////////////////////////////////////////////////////////////

void setup_break (void)
{
    HANDLE hConIn = GetStdHandle (STD_INPUT_HANDLE);

    SetConsoleMode (hConIn, ENABLE_PROCESSED_INPUT);
    FlushConsoleInputBuffer (hConIn);
    SetConsoleCtrlHandler (ctrl_handler, TRUE);
    break_flag = 0;
}

//////////////////////////////////////////////////////////////////////////////
// Function to determine whether ^C or ^Break has been issued by user.      //
//////////////////////////////////////////////////////////////////////////////

int check_break (void)
{
    return break_flag;
}

//////////////////////////////////////////////////////////////////////////////
// Function to clear the stderr console to the end of the current line (and //
// go to the beginning next line).                                          //
//////////////////////////////////////////////////////////////////////////////

void finish_line (void)
{
    HANDLE hConIn = GetStdHandle (STD_ERROR_HANDLE);
    CONSOLE_SCREEN_BUFFER_INFO coninfo;

    if (hConIn && GetConsoleScreenBufferInfo (hConIn, &coninfo)) {
	unsigned char spaces = coninfo.dwSize.X - coninfo.dwCursorPosition.X;

	while (spaces--)
	    fputc (' ', stderr);
    }
    else
	fputc ('\n', stderr);
}
#else
//////////////////////////////////////////////////////////////////////////////
// Function to clear the stderr console to the end of the current line (and //
// go to the beginning next line).                                          //
//////////////////////////////////////////////////////////////////////////////

void finish_line (void)
{
    fprintf (stderr, "        \n");
}

//////////////////////////////////////////////////////////////////////////////
// Function to initialize console for intercepting ^C and ^Break.           //
//////////////////////////////////////////////////////////////////////////////

void setup_break (void)
{
}

//////////////////////////////////////////////////////////////////////////////
// Function to determine whether ^C or ^Break has been issued by user.      //
//////////////////////////////////////////////////////////////////////////////

int check_break (void)
{
    return 0;
}

#endif

//////////////////////////// File I/O Wrapper ////////////////////////////////

int DoReadFile (FILE *hFile, void *lpBuffer, uint32_t nNumberOfBytesToRead, uint32_t *lpNumberOfBytesRead)
{
    uint32_t bcount;

    *lpNumberOfBytesRead = 0;

    while (nNumberOfBytesToRead) {
	bcount = fread ((uchar *) lpBuffer + *lpNumberOfBytesRead, 1, nNumberOfBytesToRead, hFile);

	if (bcount) {
	    *lpNumberOfBytesRead += bcount;
	    nNumberOfBytesToRead -= bcount;
	}
	else
	    break;
    }

    return !ferror (hFile);
}

int DoWriteFile (FILE *hFile, void *lpBuffer, uint32_t nNumberOfBytesToWrite, uint32_t *lpNumberOfBytesWritten)
{
    uint32_t bcount;

    *lpNumberOfBytesWritten = 0;

    while (nNumberOfBytesToWrite) {
	bcount = fwrite ((uchar *) lpBuffer + *lpNumberOfBytesWritten, 1, nNumberOfBytesToWrite, hFile);

	if (bcount) {
	    *lpNumberOfBytesWritten += bcount;
	    nNumberOfBytesToWrite -= bcount;
	}
	else
	    break;
    }

    return !ferror (hFile);
}

uint32_t DoGetFileSize (FILE *hFile)
{
    struct stat statbuf;

    if (!hFile || fstat (fileno (hFile), &statbuf) || !(statbuf.st_mode & S_IFREG))
	return 0;

    return statbuf.st_size;
}

uint32_t DoGetFilePosition (FILE *hFile)
{
    return ftell (hFile);
}

int DoSetFilePositionAbsolute (FILE *hFile, uint32_t pos)
{
    return fseek (hFile, pos, SEEK_SET);
}

int DoSetFilePositionRelative (FILE *hFile, int32_t pos, int mode)
{
    return fseek (hFile, pos, mode);
}

// if ungetc() is not available, a seek of -1 is fine also because we do not
// change the byte read.

int DoUngetc (int c, FILE *hFile)
{
    return ungetc (c, hFile);
}

int DoCloseHandle (FILE *hFile)
{
    return hFile ? !fclose (hFile) : 0;
}

int DoTruncateFile(FILE *hFile)
{
    if (hFile) {
	fflush (hFile);
#if defined(WIN32)
	return !chsize (fileno (hFile), 0);
#else
	return !ftruncate(fileno (hFile), 0);
#endif
    }

    return 0;
}

int DoDeleteFile (char *filename)
{
    return !remove (filename);
}

See more files for this project here

EmStar

EmStar is a software system for developing and deploying wireless sensor networks involving Linux-based platforms. As the wireless sensor network community has attempted to deploy more complex designs---large-scale, long-lived systems that need self-organization and adaptivity---a number of difficult software design issues have arisen. Advances in software design have not kept pace with the capabilities of hardware. This is because designing for an adaptive, efficient, and useful sensor network has turned out to be surprisingly complex and difficult. EmStar is a Linux-based software framework, whose goal is to dramatically reduce this complexity, enabling work to be shared and reused, and simplifying and speeding the design of new sensor network applications.

Project homepage: http://cvs.cens.ucla.edu/emstar/
Programming language(s): C,Shell Script
License: other

  Makefile
  bits.c
  extra1.c
  extra2.c
  float.c
  metadata.c
  pack.c
  test.sh
  test_main.c
  utils.c
  wavpack.c
  wavpack.h
  wavpack_defs.h
  words.c
  wputils.c
  wputils.h