4 * Copyright (c) 2006-2010 Pacman Development Team <pacman-dev@archlinux.org>
5 * Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
6 * Copyright (c) 2005 by Aurelien Foret <orelien@chez.com>
7 * Copyright (c) 2005 by Christian Hamar <krics@linuxforum.hu>
8 * Copyright (c) 2006 by David Kimpe <dnaku@frugalware.org>
9 * Copyright (c) 2005, 2006 by Miklos Vajna <vmiklos@frugalware.org>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program. If not, see <http://www.gnu.org/licenses/>.
38 #include <sys/types.h>
44 #include <archive_entry.h>
47 #include <openssl/md5.h>
57 #include "alpm_list.h"
61 /* This is a replacement for strsep which is not portable (missing on Solaris).
62 * Copyright (c) 2001 by François Gouget <fgouget_at_codeweavers.com> */
63 char* strsep(char** str
, const char* delims
)
74 if (strchr(delims
,**str
)!=NULL
) {
81 /* There is no other token */
87 int _alpm_makepath(const char *path
)
89 return(_alpm_makepath_mode(path
, 0755));
92 /* does the same thing as 'mkdir -p' */
93 int _alpm_makepath_mode(const char *path
, mode_t mode
)
95 /* A bit of pointer hell here. Descriptions:
96 * orig - a copy of path so we can safely butcher it with strsep
97 * str - the current position in the path string (after the delimiter)
98 * ptr - the original position of str after calling strsep
99 * incr - incrementally generated path for use in stat/mkdir call
101 char *orig
, *str
, *ptr
, *incr
;
102 mode_t oldmask
= umask(0000);
106 incr
= calloc(strlen(orig
) + 1, sizeof(char));
108 while((ptr
= strsep(&str
, "/"))) {
110 /* we have another path component- append the newest component to
111 * existing string and create one more level of dir structure */
114 if(access(incr
, F_OK
)) {
115 if(mkdir(incr
, mode
)) {
128 #define CPBUFSIZE 8 * 1024
130 int _alpm_copyfile(const char *src
, const char *dest
)
137 in
= fopen(src
, "rb");
141 out
= fopen(dest
, "wb");
147 CALLOC(buf
, (size_t)CPBUFSIZE
, (size_t)1, ret
= 1; goto cleanup
;);
149 /* do the actual file copy */
150 while((len
= fread(buf
, 1, CPBUFSIZE
, in
))) {
152 nwritten
= fwrite(buf
, 1, len
, out
);
153 if((nwritten
!= len
) || ferror(out
)) {
154 pm_errno
= PM_ERR_WRITE
;
155 _alpm_log(PM_LOG_ERROR
, _("error writing to file '%s': %s\n"),
156 dest
, strerror(errno
));
162 /* chmod dest to permissions of src, as long as it is not a symlink */
164 if(!stat(src
, &statbuf
)) {
165 if(! S_ISLNK(statbuf
.st_mode
)) {
166 fchmod(fileno(out
), statbuf
.st_mode
);
169 /* stat was unsuccessful */
180 /* Trim whitespace and newlines from a string
182 char *_alpm_strtrim(char *str
)
187 /* string is empty, so we're done. */
191 while(isspace((unsigned char)*pch
)) {
195 memmove(str
, pch
, (strlen(pch
) + 1));
198 /* check if there wasn't anything but whitespace in the string. */
203 pch
= (str
+ (strlen(str
) - 1));
204 while(isspace((unsigned char)*pch
)) {
212 /* Create a lock file */
217 const char *file
= alpm_option_get_lockfile();
219 /* create the dir of the lockfile first */
221 ptr
= strrchr(dir
, '/');
229 fd
= open(file
, O_WRONLY
| O_CREAT
| O_EXCL
, 0000);
230 } while (fd
== -1 && errno
== EINTR
);
232 FILE *f
= fdopen(fd
, "w");
233 fprintf(f
, "%ld\n", (long)getpid());
242 /* Remove a lock file */
245 const char *file
= alpm_option_get_lockfile();
246 if(unlink(file
) == -1 && errno
!= ENOENT
) {
252 /* Compression functions */
255 * @brief Unpack a specific file in an archive.
257 * @param archive the archive to unpack
258 * @param prefix where to extract the files
259 * @param fn a file within the archive to unpack
260 * @return 0 on success, 1 on failure
262 int _alpm_unpack_single(const char *archive
, const char *prefix
, const char *fn
)
264 alpm_list_t
*list
= NULL
;
269 list
= alpm_list_add(list
, (void *)fn
);
270 ret
= _alpm_unpack(archive
, prefix
, list
, 1);
271 alpm_list_free(list
);
276 * @brief Unpack a list of files in an archive.
278 * @param archive the archive to unpack
279 * @param prefix where to extract the files
280 * @param list a list of files within the archive to unpack or
282 * @param breakfirst break after the first entry found
284 * @return 0 on success, 1 on failure
286 int _alpm_unpack(const char *archive
, const char *prefix
, alpm_list_t
*list
, int breakfirst
)
290 struct archive
*_archive
;
291 struct archive_entry
*entry
;
297 if((_archive
= archive_read_new()) == NULL
)
298 RET_ERR(PM_ERR_LIBARCHIVE
, 1);
300 archive_read_support_compression_all(_archive
);
301 archive_read_support_format_all(_archive
);
303 if(archive_read_open_filename(_archive
, archive
,
304 ARCHIVE_DEFAULT_BYTES_PER_BLOCK
) != ARCHIVE_OK
) {
305 _alpm_log(PM_LOG_ERROR
, _("could not open %s: %s\n"), archive
,
306 archive_error_string(_archive
));
307 RET_ERR(PM_ERR_PKG_OPEN
, 1);
310 oldmask
= umask(0022);
312 /* save the cwd so we can restore it later */
313 if(getcwd(cwd
, PATH_MAX
) == NULL
) {
314 _alpm_log(PM_LOG_ERROR
, _("could not get current working directory\n"));
319 /* just in case our cwd was removed in the upgrade operation */
320 if(chdir(prefix
) != 0) {
321 _alpm_log(PM_LOG_ERROR
, _("could not change directory to %s (%s)\n"), prefix
, strerror(errno
));
326 while(archive_read_next_header(_archive
, &entry
) == ARCHIVE_OK
) {
327 const struct stat
*st
;
328 const char *entryname
; /* the name of the file in the archive */
330 st
= archive_entry_stat(entry
);
331 entryname
= archive_entry_pathname(entry
);
333 if(S_ISREG(st
->st_mode
)) {
334 archive_entry_set_perm(entry
, 0644);
335 } else if(S_ISDIR(st
->st_mode
)) {
336 archive_entry_set_perm(entry
, 0755);
339 /* If specific files were requested, skip entries that don't match. */
341 char *prefix
= strdup(entryname
);
342 char *p
= strstr(prefix
,"/");
346 char *found
= alpm_list_find_str(list
, prefix
);
349 if (archive_read_data_skip(_archive
) != ARCHIVE_OK
) {
355 _alpm_log(PM_LOG_DEBUG
, "extracting: %s\n", entryname
);
359 /* Extract the archive entry. */
360 int readret
= archive_read_extract(_archive
, entry
, 0);
361 if(readret
== ARCHIVE_WARN
) {
362 /* operation succeeded but a non-critical error was encountered */
363 _alpm_log(PM_LOG_WARNING
, _("warning given while extracting %s (%s)\n"),
364 entryname
, archive_error_string(_archive
));
365 } else if(readret
!= ARCHIVE_OK
) {
366 _alpm_log(PM_LOG_ERROR
, _("could not extract %s (%s)\n"),
367 entryname
, archive_error_string(_archive
));
379 archive_read_finish(_archive
);
380 if(restore_cwd
&& chdir(cwd
) != 0) {
381 _alpm_log(PM_LOG_ERROR
, _("could not change directory to %s (%s)\n"), cwd
, strerror(errno
));
386 /* does the same thing as 'rm -rf' */
387 int _alpm_rmrf(const char *path
)
395 if(_alpm_lstat(path
, &st
) == 0) {
396 if(!S_ISDIR(st
.st_mode
)) {
400 if(errno
== ENOENT
) {
407 dirp
= opendir(path
);
411 for(dp
= readdir(dirp
); dp
!= NULL
; dp
= readdir(dirp
)) {
413 sprintf(name
, "%s/%s", path
, dp
->d_name
);
414 if(strcmp(dp
->d_name
, "..") != 0 && strcmp(dp
->d_name
, ".") != 0) {
415 errflag
+= _alpm_rmrf(name
);
429 int _alpm_logaction(int usesyslog
, FILE *f
, const char *fmt
, va_list args
)
434 /* we can't use a va_list more than once, so we need to copy it
435 * so we can use the original when calling vfprintf below. */
437 va_copy(args_syslog
, args
);
438 vsyslog(LOG_WARNING
, fmt
, args_syslog
);
449 /* Use ISO-8601 date format */
450 fprintf(f
, "[%04d-%02d-%02d %02d:%02d] ",
451 tm
->tm_year
+1900, tm
->tm_mon
+1, tm
->tm_mday
,
452 tm
->tm_hour
, tm
->tm_min
);
453 ret
= vfprintf(f
, fmt
, args
);
460 int _alpm_run_chroot(const char *root
, const char *path
, char *const argv
[])
470 /* save the cwd so we can restore it later */
471 if(getcwd(cwd
, PATH_MAX
) == NULL
) {
472 _alpm_log(PM_LOG_ERROR
, _("could not get current working directory\n"));
477 /* just in case our cwd was removed in the upgrade operation */
478 if(chdir(root
) != 0) {
479 _alpm_log(PM_LOG_ERROR
, _("could not change directory to %s (%s)\n"), root
, strerror(errno
));
483 _alpm_log(PM_LOG_DEBUG
, "executing \"%s\" under chroot \"%s\"\n", path
, root
);
485 /* Flush open fds before fork() to avoid cloning buffers */
488 if(pipe(pipefd
) == -1) {
489 _alpm_log(PM_LOG_ERROR
, _("could not create pipe (%s)\n"), strerror(errno
));
494 /* fork- parent and child each have seperate code blocks below */
497 _alpm_log(PM_LOG_ERROR
, _("could not fork a new process (%s)\n"), strerror(errno
));
503 /* this code runs for the child only (the actual chroot/exec) */
506 while(dup2(pipefd
[1], 1) == -1 && errno
== EINTR
);
507 while(dup2(pipefd
[1], 2) == -1 && errno
== EINTR
);
511 /* use fprintf instead of _alpm_log to send output through the parent */
512 if(chroot(root
) != 0) {
513 fprintf(stderr
, _("could not change the root directory (%s)\n"), strerror(errno
));
516 if(chdir("/") != 0) {
517 fprintf(stderr
, _("could not change directory to / (%s)\n"), strerror(errno
));
522 fprintf(stderr
, _("call to execv failed (%s)\n"), strerror(errno
));
525 /* this code runs for the parent only (wait on the child) */
530 pipe
= fdopen(pipefd
[0], "r");
537 if(fgets(line
, PATH_MAX
, pipe
) == NULL
)
539 alpm_logaction("%s", line
);
540 EVENT(handle
->trans
, PM_TRANS_EVT_SCRIPTLET_INFO
, line
, NULL
);
545 while(waitpid(pid
, &status
, 0) == -1) {
547 _alpm_log(PM_LOG_ERROR
, _("call to waitpid failed (%s)\n"), strerror(errno
));
553 /* report error from above after the child has exited */
555 _alpm_log(PM_LOG_ERROR
, _("could not open pipe (%s)\n"), strerror(errno
));
558 /* check the return status, make sure it is 0 (success) */
559 if(WIFEXITED(status
)) {
560 _alpm_log(PM_LOG_DEBUG
, "call to waitpid succeeded\n");
561 if(WEXITSTATUS(status
) != 0) {
562 _alpm_log(PM_LOG_ERROR
, _("command failed to execute correctly\n"));
569 if(restore_cwd
&& chdir(cwd
) != 0) {
570 _alpm_log(PM_LOG_ERROR
, _("could not change directory to %s (%s)\n"), cwd
, strerror(errno
));
576 int _alpm_ldconfig(const char *root
)
580 _alpm_log(PM_LOG_DEBUG
, "running ldconfig\n");
582 snprintf(line
, PATH_MAX
, "%setc/ld.so.conf", root
);
583 if(access(line
, F_OK
) == 0) {
584 snprintf(line
, PATH_MAX
, "%ssbin/ldconfig", root
);
585 if(access(line
, X_OK
) == 0) {
586 char *argv
[] = { "ldconfig", NULL
};
587 _alpm_run_chroot(root
, "/sbin/ldconfig", argv
);
594 /* Helper function for comparing strings using the
595 * alpm "compare func" signature */
596 int _alpm_str_cmp(const void *s1
, const void *s2
)
598 return(strcmp(s1
, s2
));
601 /** Find a filename in a registered alpm cachedir.
602 * @param filename name of file to find
603 * @return malloced path of file, NULL if not found
605 char *_alpm_filecache_find(const char* filename
)
611 /* Loop through the cache dirs until we find a matching file */
612 for(i
= alpm_option_get_cachedirs(); i
; i
= alpm_list_next(i
)) {
613 snprintf(path
, PATH_MAX
, "%s%s", (char*)alpm_list_getdata(i
),
615 if(access(path
, R_OK
) == 0) {
616 retpath
= strdup(path
);
617 _alpm_log(PM_LOG_DEBUG
, "found cached pkg: %s\n", retpath
);
621 /* package wasn't found in any cachedir */
625 /** Check the alpm cachedirs for existance and find a writable one.
626 * If no valid cache directory can be found, use /tmp.
627 * @return pointer to a writable cache directory.
629 const char *_alpm_filecache_setup(void)
632 alpm_list_t
*i
, *tmp
;
635 /* Loop through the cache dirs until we find a writeable dir */
636 for(i
= alpm_option_get_cachedirs(); i
; i
= alpm_list_next(i
)) {
637 cachedir
= alpm_list_getdata(i
);
638 if(stat(cachedir
, &buf
) != 0) {
639 /* cache directory does not exist.... try creating it */
640 _alpm_log(PM_LOG_WARNING
, _("no %s cache exists, creating...\n"),
642 if(_alpm_makepath(cachedir
) == 0) {
643 _alpm_log(PM_LOG_DEBUG
, "using cachedir: %s\n", cachedir
);
646 } else if(S_ISDIR(buf
.st_mode
) && (buf
.st_mode
& S_IWUSR
)) {
647 _alpm_log(PM_LOG_DEBUG
, "using cachedir: %s\n", cachedir
);
652 /* we didn't find a valid cache directory. use /tmp. */
653 tmp
= alpm_list_add(NULL
, strdup("/tmp/"));
654 alpm_option_set_cachedirs(tmp
);
655 _alpm_log(PM_LOG_DEBUG
, "using cachedir: %s", "/tmp/\n");
656 _alpm_log(PM_LOG_WARNING
, _("couldn't create package cache, using /tmp instead\n"));
657 return(alpm_list_getdata(tmp
));
660 /** lstat wrapper that treats /path/dirsymlink/ the same as /path/dirsymlink.
661 * Linux lstat follows POSIX semantics and still performs a dereference on
662 * the first, and for uses of lstat in libalpm this is not what we want.
663 * @param path path to file to lstat
664 * @param buf structure to fill with stat information
665 * @return the return code from lstat
667 int _alpm_lstat(const char *path
, struct stat
*buf
)
670 char *newpath
= strdup(path
);
671 int len
= strlen(newpath
);
673 /* strip the trailing slash if one exists */
674 if(len
!= 0 && newpath
[len
- 1] == '/') {
675 newpath
[len
- 1] = '\0';
678 ret
= lstat(newpath
, buf
);
685 static int md5_file(const char *path
, unsigned char output
[16])
692 CALLOC(buf
, 8192, sizeof(unsigned char), return(1));
694 if((f
= fopen(path
, "rb")) == NULL
) {
701 while((n
= fread(buf
, 1, sizeof(buf
), f
)) > 0) {
702 MD5_Update(&ctx
, buf
, n
);
705 MD5_Final(output
, &ctx
);
707 memset(&ctx
, 0, sizeof(MD5_CTX
));
720 /** Get the md5 sum of file.
721 * @param filename name of the file
722 * @return the checksum on success, NULL on error
723 * @addtogroup alpm_misc
725 char SYMEXPORT
*alpm_compute_md5sum(const char *filename
)
727 unsigned char output
[16];
733 ASSERT(filename
!= NULL
, return(NULL
));
735 /* allocate 32 chars plus 1 for null */
736 md5sum
= calloc(33, sizeof(char));
737 /* defined above for OpenSSL, otherwise defined in md5.h */
738 ret
= md5_file(filename
, output
);
741 RET_ERR(PM_ERR_NOT_A_FILE
, NULL
);
744 /* Convert the result to something readable */
745 for (i
= 0; i
< 16; i
++) {
746 /* sprintf is acceptable here because we know our output */
747 sprintf(md5sum
+(i
* 2), "%02x", output
[i
]);
751 _alpm_log(PM_LOG_DEBUG
, "md5(%s) = %s\n", filename
, md5sum
);
755 int _alpm_test_md5sum(const char *filepath
, const char *md5sum
)
760 md5sum2
= alpm_compute_md5sum(filepath
);
762 if(md5sum
== NULL
|| md5sum2
== NULL
) {
764 } else if(strcmp(md5sum
, md5sum2
) != 0) {
774 /* Note: does NOT handle sparse files on purpose for speed. */
775 int _alpm_archive_fgets(struct archive
*a
, struct archive_read_buffer
*b
)
782 /* have we processed this entire block? */
783 if(b
->block
+ b
->block_size
== b
->block_offset
) {
784 if(b
->ret
== ARCHIVE_EOF
) {
785 /* reached end of archive on the last read, now we are out of data */
789 /* zero-copy - this is the entire next block of data. */
790 b
->ret
= archive_read_data_block(a
, (void*)&b
->block
,
791 &b
->block_size
, &offset
);
792 b
->block_offset
= b
->block
;
794 /* error or end of archive with no data read, cleanup */
795 if(b
->ret
< ARCHIVE_OK
||
796 (b
->block_size
== 0 && b
->ret
== ARCHIVE_EOF
)) {
801 /* loop through the block looking for EOL characters */
802 for(i
= b
->block_offset
; i
< (b
->block
+ b
->block_size
); i
++) {
803 /* check if read value was null or newline */
804 if(*i
== '\0' || *i
== '\n') {
810 /* allocate our buffer, or ensure our existing one is big enough */
812 /* set the initial buffer to the read block_size */
813 CALLOC(b
->line
, b
->block_size
+ 1, sizeof(char),
814 RET_ERR(PM_ERR_MEMORY
, -1));
815 b
->line_size
= b
->block_size
+ 1;
816 b
->line_offset
= b
->line
;
818 size_t needed
= (b
->line_offset
- b
->line
) + (i
- b
->block_offset
) + 1;
819 if(needed
> b
->max_line_size
) {
820 RET_ERR(PM_ERR_MEMORY
, -1);
822 if(needed
> b
->line_size
) {
823 /* need to realloc + copy data to fit total length */
825 CALLOC(new, needed
, sizeof(char), RET_ERR(PM_ERR_MEMORY
, -1));
826 memcpy(new, b
->line
, b
->line_size
);
827 b
->line_size
= needed
;
828 b
->line_offset
= new + (b
->line_offset
- b
->line
);
835 size_t len
= i
- b
->block_offset
;
836 memcpy(b
->line_offset
, b
->block_offset
, len
);
837 b
->line_offset
[len
] = '\0';
838 b
->block_offset
= ++i
;
839 /* this is the main return point; from here you can read b->line */
842 /* we've looked through the whole block but no newline, copy it */
843 size_t len
= b
->block
+ b
->block_size
- b
->block_offset
;
844 memcpy(b
->line_offset
, b
->block_offset
, len
);
845 b
->line_offset
+= len
;
854 memset(b
, 0, sizeof(b
));
859 int _alpm_splitname(const char *target
, pmpkg_t
*pkg
)
861 /* the format of a db entry is as follows:
862 * package-version-rel/
863 * package name can contain hyphens, so parse from the back- go back
864 * two hyphens and we have split the version from the name.
868 if(target
== NULL
|| pkg
== NULL
) {
871 STRDUP(tmp
, target
, RET_ERR(PM_ERR_MEMORY
, -1));
872 p
= tmp
+ strlen(tmp
);
874 /* remove any trailing '/' */
875 while (*(p
- 1) == '/') {
880 /* do the magic parsing- find the beginning of the version string
881 * by doing two iterations of same loop to lop off two hyphens */
882 for(q
= --p
; *q
&& *q
!= '-'; q
--);
883 for(p
= --q
; *p
&& *p
!= '-'; p
--);
884 if(*p
!= '-' || p
== tmp
) {
888 /* copy into fields and return */
892 STRDUP(pkg
->version
, p
+1, RET_ERR(PM_ERR_MEMORY
, -1));
893 /* insert a terminator at the end of the name (on hyphen)- then copy it */
898 STRDUP(pkg
->name
, tmp
, RET_ERR(PM_ERR_MEMORY
, -1));
899 pkg
->name_hash
= _alpm_hash_sdbm(pkg
->name
);
906 * Hash the given string to an unsigned long value.
907 * This is the standard sdbm hashing algorithm.
908 * @param str string to hash
909 * @return the hash value of the given string
911 unsigned long _alpm_hash_sdbm(const char *str
)
913 unsigned long hash
= 0;
919 while((c
= *str
++)) {
920 hash
= c
+ (hash
<< 6) + (hash
<< 16) - hash
;
926 /* vim: set ts=2 sw=2 noet: */