my_lib.c

php-4.4.7学习linux时下载的源代码

	    && ptr[rlen - 1] == '.')
	{
	  VOID(strmov(esa,ptr));
	  esa[rlen - 1] = FN_C_AFTER_DIR;
	  esa[rlen] = '\0';
	  return (directory_file_name (dst, esa));
	}
	else
	  dst[slen - 1] = ':';
      }
      VOID(strmov(dst+slen,"[000000]"));
      slen += 8;
    }
    VOID(strmov(strmov(dst+slen,rptr+1)-1,".DIR.1"));
    return dst;
  }
  VOID(strmov(dst, src));
  if (dst[slen] == '/' && slen > 1)
    dst[slen] = 0;
  return dst;
#endif	/* VMS */
} /* directory_file_name */

#elif defined(WIN32)

/*
*****************************************************************************
** Read long filename using windows rutines
*****************************************************************************
*/

MY_DIR	*my_dir(const char *path, myf MyFlags)
{
  struct fileinfo *fnames;
  char	       *buffer, *obuffer, *tempptr;
  int		eof,i,fcnt,firstfcnt,length,maxfcnt;
  uint		size;
#ifdef __BORLANDC__
  struct ffblk       find;
#else
  struct _finddata_t find;
#endif
  ushort	mode;
  char		tmp_path[FN_REFLEN],*tmp_file,attrib;
  my_ptrdiff_t	diff;
#ifdef _WIN64
  __int64       handle;
#else
  long		handle;
#endif
  DBUG_ENTER("my_dir");
  DBUG_PRINT("my",("path: '%s' stat: %d  MyFlags: %d",path,MyFlags));

  /* Put LIB-CHAR as last path-character if not there */

  tmp_file=tmp_path;
  if (!*path)
    *tmp_file++ ='.';				/* From current dir */
  tmp_file= strmov(tmp_file,path);
  if (tmp_file[-1] == FN_DEVCHAR)
    *tmp_file++= '.';				/* From current dev-dir */
  if (tmp_file[-1] != FN_LIBCHAR)
    *tmp_file++ =FN_LIBCHAR;
  tmp_file[0]='*';				/* MSDOS needs this !??? */
  tmp_file[1]='.';
  tmp_file[2]='*';
  tmp_file[3]='\0';

#ifdef __BORLANDC__
  if ((handle= findfirst(tmp_path,&find,0)) == -1L)
    goto error;
#else
  if ((handle=_findfirst(tmp_path,&find)) == -1L)
    goto error;
#endif

  size = STARTSIZE;
  firstfcnt = maxfcnt = (size - sizeof(MY_DIR)) /
    (sizeof(struct fileinfo) + FN_LEN);
  if ((buffer = (char *) my_malloc(size, MyFlags)) == 0)
    goto error;
  fnames=   (struct fileinfo *) (buffer + sizeof(MY_DIR));
  tempptr = (char *) (fnames + maxfcnt);

  fcnt = 0;
  for (;;)
  {
    do
    {
      fnames[fcnt].name = tempptr;
#ifdef __BORLANDC__
      tempptr = strmov(tempptr,find.ff_name) + 1;
      fnames[fcnt].mystat.st_size=find.ff_fsize;
      fnames[fcnt].mystat.st_uid=fnames[fcnt].mystat.st_gid=0;
      mode=MY_S_IREAD; attrib=find.ff_attrib;
#else
      tempptr = strmov(tempptr,find.name) + 1;
      fnames[fcnt].mystat.st_size=find.size;
      fnames[fcnt].mystat.st_uid=fnames[fcnt].mystat.st_gid=0;
      mode=MY_S_IREAD; attrib=find.attrib;
#endif
      if (!(attrib & _A_RDONLY))
	mode|=MY_S_IWRITE;
      if (attrib & _A_SUBDIR)
	mode|=MY_S_IFDIR;
      fnames[fcnt].mystat.st_mode=mode;
#ifdef __BORLANDC__
      fnames[fcnt].mystat.st_mtime=((uint32) find.ff_ftime);
#else
      fnames[fcnt].mystat.st_mtime=((uint32) find.time_write);
#endif
      ++fcnt;
#ifdef __BORLANDC__
    } while ((eof= findnext(&find)) == 0 && fcnt < maxfcnt);
#else
    } while ((eof= _findnext(handle,&find)) == 0 && fcnt < maxfcnt);
#endif

    DBUG_PRINT("test",("eof: %d  errno: %d",eof,errno));
    if (eof)
      break;
    size += STARTSIZE; obuffer = buffer;
    if (!(buffer = (char *) my_realloc((gptr) buffer, size,
				       MyFlags | MY_FREE_ON_ERROR)))
      goto error;
    length= sizeof(struct fileinfo ) * firstfcnt;
    diff=    PTR_BYTE_DIFF(buffer , obuffer) +length;
    fnames=  (struct fileinfo *) (buffer + sizeof(MY_DIR));
    tempptr= ADD_TO_PTR(tempptr,diff,char*);
    for (i = 0; i < maxfcnt; i++)
      fnames[i].name = ADD_TO_PTR(fnames[i].name,diff,char*);

    /* move filenames upp a bit */
    maxfcnt += firstfcnt;
    bmove_upp(tempptr,ADD_TO_PTR(tempptr,-length,char*),
	      (int) PTR_BYTE_DIFF(tempptr,fnames+maxfcnt));
  }
  {
    MY_DIR * s = (MY_DIR *) buffer;
    s->number_off_files = (uint) fcnt;
    s->dir_entry = fnames;
  }
  if (!(MyFlags & MY_DONT_SORT))
    qsort(fnames,fcnt,sizeof(struct fileinfo),(qsort_cmp) comp_names);
#ifndef __BORLANDC__
  _findclose(handle);
#endif
  DBUG_RETURN((MY_DIR *) buffer);

error:
  my_errno=errno;
#ifndef __BORLANDC__
  if (handle != -1)
      _findclose(handle);
#endif
  if (MyFlags & MY_FAE+MY_WME)
    my_error(EE_DIR,MYF(ME_BELL+ME_WAITTANG),path,errno);
  DBUG_RETURN((MY_DIR *) NULL);
} /* my_dir */

#else /* MSDOS and not WIN32 */


/******************************************************************************
** At MSDOS you always get stat of files, but time is in packed MSDOS-format
******************************************************************************/

MY_DIR	*my_dir(const char* path, myf MyFlags)
{
  struct fileinfo *fnames;
  char	       *buffer, *obuffer, *tempptr;
  int		eof,i,fcnt,firstfcnt,length,maxfcnt;
  uint		size;
  struct find_t find;
  ushort	mode;
  char		tmp_path[FN_REFLEN],*tmp_file,attrib;
  my_ptrdiff_t	diff;
  DBUG_ENTER("my_dir");
  DBUG_PRINT("my",("path: '%s' stat: %d  MyFlags: %d",path,MyFlags));

  /* Put LIB-CHAR as last path-character if not there */

  tmp_file=tmp_path;
  if (!*path)
    *tmp_file++ ='.';				/* From current dir */
  tmp_file= strmov(tmp_file,path);
  if (tmp_file[-1] == FN_DEVCHAR)
    *tmp_file++= '.';				/* From current dev-dir */
  if (tmp_file[-1] != FN_LIBCHAR)
    *tmp_file++ =FN_LIBCHAR;
  tmp_file[0]='*';				/* MSDOS needs this !??? */
  tmp_file[1]='.';
  tmp_file[2]='*';
  tmp_file[3]='\0';

  if (_dos_findfirst(tmp_path,_A_NORMAL | _A_SUBDIR, &find))
    goto error;

  size = STARTSIZE;
  firstfcnt = maxfcnt = (size - sizeof(MY_DIR)) /
    (sizeof(struct fileinfo) + FN_LEN);
  if ((buffer = (char *) my_malloc(size, MyFlags)) == 0)
    goto error;
  fnames=   (struct fileinfo *) (buffer + sizeof(MY_DIR));
  tempptr = (char *) (fnames + maxfcnt);

  fcnt = 0;
  for (;;)
  {
    do
    {
      fnames[fcnt].name = tempptr;
      tempptr = strmov(tempptr,find.name) + 1;
      fnames[fcnt].mystat.st_size=find.size;
      fnames[fcnt].mystat.st_uid=fnames[fcnt].mystat.st_gid=0;
      mode=MY_S_IREAD; attrib=find.attrib;
      if (!(attrib & _A_RDONLY))
	mode|=MY_S_IWRITE;
      if (attrib & _A_SUBDIR)
	mode|=MY_S_IFDIR;
      fnames[fcnt].mystat.st_mode=mode;
      fnames[fcnt].mystat.st_mtime=((uint32) find.wr_date << 16) +
					     find.wr_time;
      ++fcnt;
    } while ((eof= _dos_findnext(&find)) == 0 && fcnt < maxfcnt);

    DBUG_PRINT("test",("eof: %d  errno: %d",eof,errno));
    if (eof)
      break;
    size += STARTSIZE; obuffer = buffer;
    if (!(buffer = (char *) my_realloc((gptr) buffer, size,
				       MyFlags | MY_FREE_ON_ERROR)))
      goto error;
    length= sizeof(struct fileinfo ) * firstfcnt;
    diff=    PTR_BYTE_DIFF(buffer , obuffer) +length;
    fnames=  (struct fileinfo *) (buffer + sizeof(MY_DIR));
    tempptr= ADD_TO_PTR(tempptr,diff,char*);
    for (i = 0; i < maxfcnt; i++)
      fnames[i].name = ADD_TO_PTR(fnames[i].name,diff,char*);

    /* move filenames upp a bit */
    maxfcnt += firstfcnt;
    bmove_upp(tempptr,ADD_TO_PTR(tempptr,-length,char*),
	      (int) PTR_BYTE_DIFF(tempptr,fnames+maxfcnt));
  }
  {
    MY_DIR * s = (MY_DIR *) buffer;
    s->number_off_files = (uint) fcnt;
    s->dir_entry = fnames;
  }
  if (!(MyFlags & MY_DONT_SORT))
    qsort(fnames,fcnt,sizeof(struct fileinfo),(qsort_cmp) comp_names);
  DBUG_RETURN((MY_DIR *) buffer);

error:
  if (MyFlags & MY_FAE+MY_WME)
    my_error(EE_DIR,MYF(ME_BELL+ME_WAITTANG),path,errno);
  DBUG_RETURN((MY_DIR *) NULL);
} /* my_dir */

#endif /* WIN32 && MSDOS */

/****************************************************************************
** File status
** Note that MY_STAT is assumed to be same as struct stat
****************************************************************************/ 

int my_fstat(int Filedes, MY_STAT *stat_area, myf MyFlags )
{
  DBUG_ENTER("my_fstat");
  DBUG_PRINT("my",("fd: %d MyFlags: %d",Filedes,MyFlags));
  DBUG_RETURN(fstat(Filedes, (struct stat *) stat_area));
}

MY_STAT *my_stat(const char *path, MY_STAT *stat_area, myf my_flags)
{
  int m_used;
  DBUG_ENTER("my_stat");
  DBUG_PRINT("my", ("path: '%s', stat_area: %lx, MyFlags: %d", path,
	     (byte *) stat_area, my_flags));

  if ((m_used= (stat_area == NULL)))
    if (!(stat_area = (MY_STAT *) my_malloc(sizeof(MY_STAT), my_flags)))
      goto error;
  if ( ! stat((my_string) path, (struct stat *) stat_area) )
    DBUG_RETURN(stat_area);
  my_errno=errno;
  if (m_used)					/* Free if new area */
    my_free((gptr) stat_area,MYF(0));

error:
  if (my_flags & (MY_FAE+MY_WME))
  {
    my_error(EE_STAT, MYF(ME_BELL+ME_WAITTANG),path,my_errno);
    DBUG_RETURN((MY_STAT *) NULL);
  }
  DBUG_RETURN((MY_STAT *) NULL);
} /* my_stat */