LCOV - code coverage report
Current view: top level - src/libavformat - file.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 59 136 43.4 %
Date: 2017-06-24 07:01:58 Functions: 7 13 53.8 %

          Line data    Source code
       1             : /*
       2             :  * buffered file I/O
       3             :  * Copyright (c) 2001 Fabrice Bellard
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : #include "libavutil/avstring.h"
      23             : #include "libavutil/internal.h"
      24             : #include "libavutil/opt.h"
      25             : #include "avformat.h"
      26             : #if HAVE_DIRENT_H
      27             : #include <dirent.h>
      28             : #endif
      29             : #include <fcntl.h>
      30             : #if HAVE_IO_H
      31             : #include <io.h>
      32             : #endif
      33             : #if HAVE_UNISTD_H
      34             : #include <unistd.h>
      35             : #endif
      36             : #include <sys/stat.h>
      37             : #include <stdlib.h>
      38             : #include "os_support.h"
      39             : #include "url.h"
      40             : 
      41             : /* Some systems may not have S_ISFIFO */
      42             : #ifndef S_ISFIFO
      43             : #  ifdef S_IFIFO
      44             : #    define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)
      45             : #  else
      46             : #    define S_ISFIFO(m) 0
      47             : #  endif
      48             : #endif
      49             : 
      50             : /* Not available in POSIX.1-1996 */
      51             : #ifndef S_ISLNK
      52             : #  ifdef S_IFLNK
      53             : #    define S_ISLNK(m) (((m) & S_IFLNK) == S_IFLNK)
      54             : #  else
      55             : #    define S_ISLNK(m) 0
      56             : #  endif
      57             : #endif
      58             : 
      59             : /* Not available in POSIX.1-1996 */
      60             : #ifndef S_ISSOCK
      61             : #  ifdef S_IFSOCK
      62             : #    define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
      63             : #  else
      64             : #    define S_ISSOCK(m) 0
      65             : #  endif
      66             : #endif
      67             : 
      68             : /* standard file protocol */
      69             : 
      70             : typedef struct FileContext {
      71             :     const AVClass *class;
      72             :     int fd;
      73             :     int trunc;
      74             :     int blocksize;
      75             :     int follow;
      76             : #if HAVE_DIRENT_H
      77             :     DIR *dir;
      78             : #endif
      79             : } FileContext;
      80             : 
      81             : static const AVOption file_options[] = {
      82             :     { "truncate", "truncate existing files on write", offsetof(FileContext, trunc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
      83             :     { "blocksize", "set I/O operation maximum block size", offsetof(FileContext, blocksize), AV_OPT_TYPE_INT, { .i64 = INT_MAX }, 1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
      84             :     { "follow", "Follow a file as it is being written", offsetof(FileContext, follow), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
      85             :     { NULL }
      86             : };
      87             : 
      88             : static const AVOption pipe_options[] = {
      89             :     { "blocksize", "set I/O operation maximum block size", offsetof(FileContext, blocksize), AV_OPT_TYPE_INT, { .i64 = INT_MAX }, 1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
      90             :     { NULL }
      91             : };
      92             : 
      93             : static const AVClass file_class = {
      94             :     .class_name = "file",
      95             :     .item_name  = av_default_item_name,
      96             :     .option     = file_options,
      97             :     .version    = LIBAVUTIL_VERSION_INT,
      98             : };
      99             : 
     100             : static const AVClass pipe_class = {
     101             :     .class_name = "pipe",
     102             :     .item_name  = av_default_item_name,
     103             :     .option     = pipe_options,
     104             :     .version    = LIBAVUTIL_VERSION_INT,
     105             : };
     106             : 
     107      157841 : static int file_read(URLContext *h, unsigned char *buf, int size)
     108             : {
     109      157841 :     FileContext *c = h->priv_data;
     110             :     int ret;
     111      157841 :     size = FFMIN(size, c->blocksize);
     112      157841 :     ret = read(c->fd, buf, size);
     113      157841 :     if (ret == 0 && c->follow)
     114           0 :         return AVERROR(EAGAIN);
     115      157841 :     if (ret == 0)
     116       10361 :         return AVERROR_EOF;
     117      147480 :     return (ret == -1) ? AVERROR(errno) : ret;
     118             : }
     119             : 
     120      521359 : static int file_write(URLContext *h, const unsigned char *buf, int size)
     121             : {
     122      521359 :     FileContext *c = h->priv_data;
     123             :     int ret;
     124      521359 :     size = FFMIN(size, c->blocksize);
     125      521359 :     ret = write(c->fd, buf, size);
     126      521359 :     return (ret == -1) ? AVERROR(errno) : ret;
     127             : }
     128             : 
     129           0 : static int file_get_handle(URLContext *h)
     130             : {
     131           0 :     FileContext *c = h->priv_data;
     132           0 :     return c->fd;
     133             : }
     134             : 
     135       32641 : static int file_check(URLContext *h, int mask)
     136             : {
     137       32641 :     int ret = 0;
     138       32641 :     const char *filename = h->filename;
     139       32641 :     av_strstart(filename, "file:", &filename);
     140             : 
     141             :     {
     142             : #if HAVE_ACCESS && defined(R_OK)
     143       32641 :     if (access(filename, F_OK) < 0)
     144        7822 :         return AVERROR(errno);
     145       24819 :     if (mask&AVIO_FLAG_READ)
     146       24819 :         if (access(filename, R_OK) >= 0)
     147       24819 :             ret |= AVIO_FLAG_READ;
     148       24819 :     if (mask&AVIO_FLAG_WRITE)
     149           0 :         if (access(filename, W_OK) >= 0)
     150           0 :             ret |= AVIO_FLAG_WRITE;
     151             : #else
     152             :     struct stat st;
     153             : #   ifndef _WIN32
     154             :     ret = stat(filename, &st);
     155             : #   else
     156             :     ret = win32_stat(filename, &st);
     157             : #   endif
     158             :     if (ret < 0)
     159             :         return AVERROR(errno);
     160             : 
     161             :     ret |= st.st_mode&S_IRUSR ? mask&AVIO_FLAG_READ  : 0;
     162             :     ret |= st.st_mode&S_IWUSR ? mask&AVIO_FLAG_WRITE : 0;
     163             : #endif
     164             :     }
     165       24819 :     return ret;
     166             : }
     167             : 
     168           0 : static int file_delete(URLContext *h)
     169             : {
     170             : #if HAVE_UNISTD_H
     171             :     int ret;
     172           0 :     const char *filename = h->filename;
     173           0 :     av_strstart(filename, "file:", &filename);
     174             : 
     175           0 :     ret = rmdir(filename);
     176           0 :     if (ret < 0 && errno == ENOTDIR)
     177           0 :         ret = unlink(filename);
     178           0 :     if (ret < 0)
     179           0 :         return AVERROR(errno);
     180             : 
     181           0 :     return ret;
     182             : #else
     183             :     return AVERROR(ENOSYS);
     184             : #endif /* HAVE_UNISTD_H */
     185             : }
     186             : 
     187           0 : static int file_move(URLContext *h_src, URLContext *h_dst)
     188             : {
     189           0 :     const char *filename_src = h_src->filename;
     190           0 :     const char *filename_dst = h_dst->filename;
     191           0 :     av_strstart(filename_src, "file:", &filename_src);
     192           0 :     av_strstart(filename_dst, "file:", &filename_dst);
     193             : 
     194           0 :     if (rename(filename_src, filename_dst) < 0)
     195           0 :         return AVERROR(errno);
     196             : 
     197           0 :     return 0;
     198             : }
     199             : 
     200             : #if CONFIG_FILE_PROTOCOL
     201             : 
     202       68758 : static int file_open(URLContext *h, const char *filename, int flags)
     203             : {
     204       68758 :     FileContext *c = h->priv_data;
     205             :     int access;
     206             :     int fd;
     207             :     struct stat st;
     208             : 
     209       68758 :     av_strstart(filename, "file:", &filename);
     210             : 
     211       68758 :     if (flags & AVIO_FLAG_WRITE && flags & AVIO_FLAG_READ) {
     212           0 :         access = O_CREAT | O_RDWR;
     213           0 :         if (c->trunc)
     214           0 :             access |= O_TRUNC;
     215       68758 :     } else if (flags & AVIO_FLAG_WRITE) {
     216        1882 :         access = O_CREAT | O_WRONLY;
     217        1882 :         if (c->trunc)
     218        1882 :             access |= O_TRUNC;
     219             :     } else {
     220       66876 :         access = O_RDONLY;
     221             :     }
     222             : #ifdef O_BINARY
     223             :     access |= O_BINARY;
     224             : #endif
     225       68758 :     fd = avpriv_open(filename, access, 0666);
     226       68758 :     if (fd == -1)
     227           1 :         return AVERROR(errno);
     228       68757 :     c->fd = fd;
     229             : 
     230       68757 :     h->is_streamed = !fstat(fd, &st) && S_ISFIFO(st.st_mode);
     231             : 
     232       68757 :     return 0;
     233             : }
     234             : 
     235             : /* XXX: use llseek */
     236      163572 : static int64_t file_seek(URLContext *h, int64_t pos, int whence)
     237             : {
     238      163572 :     FileContext *c = h->priv_data;
     239             :     int64_t ret;
     240             : 
     241      163572 :     if (whence == AVSEEK_SIZE) {
     242             :         struct stat st;
     243       78263 :         ret = fstat(c->fd, &st);
     244       78263 :         return ret < 0 ? AVERROR(errno) : (S_ISFIFO(st.st_mode) ? 0 : st.st_size);
     245             :     }
     246             : 
     247       85309 :     ret = lseek(c->fd, pos, whence);
     248             : 
     249       85309 :     return ret < 0 ? AVERROR(errno) : ret;
     250             : }
     251             : 
     252       68757 : static int file_close(URLContext *h)
     253             : {
     254       68757 :     FileContext *c = h->priv_data;
     255       68757 :     return close(c->fd);
     256             : }
     257             : 
     258           0 : static int file_open_dir(URLContext *h)
     259             : {
     260             : #if HAVE_LSTAT
     261           0 :     FileContext *c = h->priv_data;
     262             : 
     263           0 :     c->dir = opendir(h->filename);
     264           0 :     if (!c->dir)
     265           0 :         return AVERROR(errno);
     266             : 
     267           0 :     return 0;
     268             : #else
     269             :     return AVERROR(ENOSYS);
     270             : #endif /* HAVE_LSTAT */
     271             : }
     272             : 
     273           0 : static int file_read_dir(URLContext *h, AVIODirEntry **next)
     274             : {
     275             : #if HAVE_LSTAT
     276           0 :     FileContext *c = h->priv_data;
     277             :     struct dirent *dir;
     278           0 :     char *fullpath = NULL;
     279             : 
     280           0 :     *next = ff_alloc_dir_entry();
     281           0 :     if (!*next)
     282           0 :         return AVERROR(ENOMEM);
     283             :     do {
     284           0 :         errno = 0;
     285           0 :         dir = readdir(c->dir);
     286           0 :         if (!dir) {
     287           0 :             av_freep(next);
     288           0 :             return AVERROR(errno);
     289             :         }
     290           0 :     } while (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."));
     291             : 
     292           0 :     fullpath = av_append_path_component(h->filename, dir->d_name);
     293           0 :     if (fullpath) {
     294             :         struct stat st;
     295           0 :         if (!lstat(fullpath, &st)) {
     296           0 :             if (S_ISDIR(st.st_mode))
     297           0 :                 (*next)->type = AVIO_ENTRY_DIRECTORY;
     298           0 :             else if (S_ISFIFO(st.st_mode))
     299           0 :                 (*next)->type = AVIO_ENTRY_NAMED_PIPE;
     300           0 :             else if (S_ISCHR(st.st_mode))
     301           0 :                 (*next)->type = AVIO_ENTRY_CHARACTER_DEVICE;
     302           0 :             else if (S_ISBLK(st.st_mode))
     303           0 :                 (*next)->type = AVIO_ENTRY_BLOCK_DEVICE;
     304           0 :             else if (S_ISLNK(st.st_mode))
     305           0 :                 (*next)->type = AVIO_ENTRY_SYMBOLIC_LINK;
     306           0 :             else if (S_ISSOCK(st.st_mode))
     307           0 :                 (*next)->type = AVIO_ENTRY_SOCKET;
     308           0 :             else if (S_ISREG(st.st_mode))
     309           0 :                 (*next)->type = AVIO_ENTRY_FILE;
     310             :             else
     311           0 :                 (*next)->type = AVIO_ENTRY_UNKNOWN;
     312             : 
     313           0 :             (*next)->group_id = st.st_gid;
     314           0 :             (*next)->user_id = st.st_uid;
     315           0 :             (*next)->size = st.st_size;
     316           0 :             (*next)->filemode = st.st_mode & 0777;
     317           0 :             (*next)->modification_timestamp = INT64_C(1000000) * st.st_mtime;
     318           0 :             (*next)->access_timestamp =  INT64_C(1000000) * st.st_atime;
     319           0 :             (*next)->status_change_timestamp = INT64_C(1000000) * st.st_ctime;
     320             :         }
     321           0 :         av_free(fullpath);
     322             :     }
     323             : 
     324           0 :     (*next)->name = av_strdup(dir->d_name);
     325           0 :     return 0;
     326             : #else
     327             :     return AVERROR(ENOSYS);
     328             : #endif /* HAVE_LSTAT */
     329             : }
     330             : 
     331           0 : static int file_close_dir(URLContext *h)
     332             : {
     333             : #if HAVE_LSTAT
     334           0 :     FileContext *c = h->priv_data;
     335           0 :     closedir(c->dir);
     336           0 :     return 0;
     337             : #else
     338             :     return AVERROR(ENOSYS);
     339             : #endif /* HAVE_LSTAT */
     340             : }
     341             : 
     342             : const URLProtocol ff_file_protocol = {
     343             :     .name                = "file",
     344             :     .url_open            = file_open,
     345             :     .url_read            = file_read,
     346             :     .url_write           = file_write,
     347             :     .url_seek            = file_seek,
     348             :     .url_close           = file_close,
     349             :     .url_get_file_handle = file_get_handle,
     350             :     .url_check           = file_check,
     351             :     .url_delete          = file_delete,
     352             :     .url_move            = file_move,
     353             :     .priv_data_size      = sizeof(FileContext),
     354             :     .priv_data_class     = &file_class,
     355             :     .url_open_dir        = file_open_dir,
     356             :     .url_read_dir        = file_read_dir,
     357             :     .url_close_dir       = file_close_dir,
     358             :     .default_whitelist   = "file,crypto"
     359             : };
     360             : 
     361             : #endif /* CONFIG_FILE_PROTOCOL */
     362             : 
     363             : #if CONFIG_PIPE_PROTOCOL
     364             : 
     365        2046 : static int pipe_open(URLContext *h, const char *filename, int flags)
     366             : {
     367        2046 :     FileContext *c = h->priv_data;
     368             :     int fd;
     369             :     char *final;
     370        2046 :     av_strstart(filename, "pipe:", &filename);
     371             : 
     372        2046 :     fd = strtol(filename, &final, 10);
     373        2046 :     if((filename == final) || *final ) {/* No digits found, or something like 10ab */
     374        2045 :         if (flags & AVIO_FLAG_WRITE) {
     375        2045 :             fd = 1;
     376             :         } else {
     377           0 :             fd = 0;
     378             :         }
     379             :     }
     380             : #if HAVE_SETMODE
     381             :     setmode(fd, O_BINARY);
     382             : #endif
     383        2046 :     c->fd = fd;
     384        2046 :     h->is_streamed = 1;
     385        2046 :     return 0;
     386             : }
     387             : 
     388             : const URLProtocol ff_pipe_protocol = {
     389             :     .name                = "pipe",
     390             :     .url_open            = pipe_open,
     391             :     .url_read            = file_read,
     392             :     .url_write           = file_write,
     393             :     .url_get_file_handle = file_get_handle,
     394             :     .url_check           = file_check,
     395             :     .priv_data_size      = sizeof(FileContext),
     396             :     .priv_data_class     = &pipe_class,
     397             :     .default_whitelist   = "crypto"
     398             : };
     399             : 
     400             : #endif /* CONFIG_PIPE_PROTOCOL */

Generated by: LCOV version 1.13