1 /* $LP: LPlib/source/LPdir_unix.c,v 1.11 2004/09/23 22:07:22 _cvs_levitte Exp $ */

     2 /*

     3  * Copyright (c) 2004, Richard Levitte <richard@levitte.org>

     4  * All rights reserved.

     5  *

     6  * Redistribution and use in source and binary forms, with or without

     7  * modification, are permitted provided that the following conditions

     8  * are met:

     9  * 1. Redistributions of source code must retain the above copyright

    10  *    notice, this list of conditions and the following disclaimer.

    11  * 2. Redistributions in binary form must reproduce the above copyright

    12  *    notice, this list of conditions and the following disclaimer in the

    13  *    documentation and/or other materials provided with the distribution.

    14  * 

    15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

    16  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

    17  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

    18  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

    19  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

    20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

    21  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

    22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

    23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    26  */

    27  /*

    28  © Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.

    29  */

    30 

    31 

    32 #include <stddef.h>

    33 #include <stdlib.h>

    34 #include <limits.h>

    35 #include <string.h>

    36 #include <sys/types.h>

    37 #include <dirent.h>

    38 #include <errno.h>

    39 

    40 #if !defined(SYMBIAN)

    41 #ifndef LPDIR_H

    42 #include "LPdir.h"

    43 #endif

    44 #endif

    45 

    46 /* The POSIXly macro for the maximum number of characters in a file path

    47    is NAME_MAX.  However, some operating systems use PATH_MAX instead.

    48    Therefore, it seems natural to first check for PATH_MAX and use that,

    49    and if it doesn't exist, use NAME_MAX. */

    50 #if defined(PATH_MAX)

    51 # define LP_ENTRY_SIZE PATH_MAX

    52 #elif defined(NAME_MAX)

    53 # define LP_ENTRY_SIZE NAME_MAX

    54 #endif

    55 

    56 /* Of course, there's the possibility that neither PATH_MAX nor NAME_MAX

    57    exist.  It's also possible that NAME_MAX exists but is define to a

    58    very small value (HP-UX offers 14), so we need to check if we got a

    59    result, and if it meets a minimum standard, and create or change it

    60    if not. */

    61 #if !defined(LP_ENTRY_SIZE) || LP_ENTRY_SIZE<255

    62 # undef LP_ENTRY_SIZE

    63 # define LP_ENTRY_SIZE 255

    64 #endif

    65 

    66 struct LP_dir_context_st

    67 {

    68   DIR *dir;

    69   char entry_name[LP_ENTRY_SIZE+1];

    70 };

    71 

    72 EXPORT_C const char *LP_find_file(LP_DIR_CTX **ctx, const char *directory)

    73 {

    74   struct dirent *direntry = NULL;

    75 

    76   if (ctx == NULL || directory == NULL)

    77     {

    78       errno = EINVAL;

    79       return 0;

    80     }

    81 

    82   errno = 0;

    83   if (*ctx == NULL)

    84     {

    85       *ctx = (LP_DIR_CTX *)malloc(sizeof(LP_DIR_CTX));

    86       if (*ctx == NULL)

    87 	{

    88 	  errno = ENOMEM;

    89 	  return 0;

    90 	}

    91       memset(*ctx, '\0', sizeof(LP_DIR_CTX));

    92 

    93       (*ctx)->dir = opendir(directory);

    94       if ((*ctx)->dir == NULL)

    95 	{

    96 	  int save_errno = errno; /* Probably not needed, but I'm paranoid */

    97 	  free(*ctx);

    98 	  *ctx = NULL;

    99 	  errno = save_errno;

   100 	  return 0;

   101 	}

   102     }

   103 

   104   direntry = readdir((*ctx)->dir);

   105   if (direntry == NULL)

   106     {

   107       return 0;

   108     }

   109 

   110   strncpy((*ctx)->entry_name, direntry->d_name, sizeof((*ctx)->entry_name) - 1);

   111   (*ctx)->entry_name[sizeof((*ctx)->entry_name) - 1] = '\0';

   112   return (*ctx)->entry_name;

   113 }

   114 

   115 EXPORT_C int LP_find_file_end(LP_DIR_CTX **ctx)

   116 {

   117   if (ctx != NULL && *ctx != NULL)

   118     {

   119       int ret = closedir((*ctx)->dir);

   120 

   121       free(*ctx);

   122       switch (ret)

   123 	{

   124 	case 0:

   125 	  return 1;

   126 	case -1:

   127 	  return 0;

   128 	default:

   129 	  break;

   130 	}

   131     }

   132   errno = EINVAL;

   133   return 0;

   134 }