int main(int argc,char *argv[]) {
DIR *dfd;
struct dirent *dp;
char filename[NAME_MAX];
char absfilename[NAME_MAX];
char foldername[NAME_MAX];
char tempchar[NAME_MAX];
char buffer[BUF_SIZE];
char bytesname;
char *stroka;
ssize_t read_bytes;
ssize_t data_read_bytes;
ssize_t data_need_bytes;
ssize_t written_bytes;
int inp_file_d;
int out_file_d;
struct stat statfile;
if (argc!=4) {
printf("Arguments required.\narchivator -glue/-unglue ");
printf("input_folder/input_file output_file/output_folder\n");
} else {
if (strcmp(argv[1],"-glue")==0) {
printf("Glue operation is started.\n");
strcpy(foldername, argv[2]);
strcpy(filename, argv[3]);
dfd=opendir(foldername);
//out_file_d=open(filename, O_RDWR|O_CREAT, S_IWUSR | S_IRUSR);
out_file_d=creat(filename, S_IWUSR | S_IRUSR);
while((dp=readdir(dfd))!=NULL) {
if(strcmp(dp->d_name,".")!=0 &&
strcmp(dp->d_name,"..")!=0) {
memset(absfilename,0,sizeof(absfilename));
sprintf(absfilename,"./%s/%s", foldername, dp->d_name);
printf("Open file: %s...\n",absfilename);
inp_file_d=open(absfilename, O_RDONLY);
fstat(inp_file_d, &statfile);
//printf(" %s %lld", dp->d_name, (long long)statfile.st_size);
memset(tempchar,0,sizeof(tempchar));
sprintf(tempchar,"%s", dp->d_name);
//printf(" %s", tempchar);
bytesname=strlen(tempchar);
//printf("%d\n",bytesname);
written_bytes=write(out_file_d, &bytesname, 1);
written_bytes=write(out_file_d, tempchar, bytesname);
memset(tempchar,0,sizeof(tempchar));
sprintf(tempchar,"%lld", (long long)statfile.st_size);
//printf(" %s", tempchar);
stroka=inttobytes((long long)statfile.st_size);
//printf("%s\n%d\n",stroka,bytestoint(stroka));
bytesname=strlen(stroka);
written_bytes=write(out_file_d, &bytesname, 1);
written_bytes=write(out_file_d, stroka, bytesname);
data_read_bytes=(size_t)0;
do {
read_bytes=read(inp_file_d, buffer,BUF_SIZE);
//printf("%s\n%lld\n",buffer,(long long)read_bytes);
data_read_bytes+=read_bytes;
written_bytes=write(out_file_d, buffer, read_bytes);
} while(data_read_bytes!=statfile.st_size);
close(inp_file_d);
printf("File %s successfully added to archieve.\n",absfilename);
}
}
close(out_file_d);
closedir(dfd);
printf("\nClue operation is completed.\n");
} else if (strcmp(argv[1],"-unglue")==0) {
printf("Unglue operation is started.\n");
strcpy(filename, argv[2]);
strcpy(foldername, argv[3]);
//dfd=opendir(foldername);
mkdir(foldername,DEFAULT_MODE);
inp_file_d=open(filename, O_RDONLY);
memset(tempchar,0,sizeof(tempchar));
do {
read_bytes=read(inp_file_d, tempchar,1);
if (read_bytes==(size_t)0) break;
bytesname=tempchar[0];
memset(tempchar,0,sizeof(tempchar));
read_bytes=read(inp_file_d, tempchar,bytesname);
memset(absfilename,0,sizeof(absfilename));
sprintf(absfilename,"./%s/%s", foldername, tempchar);
out_file_d=open(absfilename, O_RDWR|O_CREAT, S_IWUSR | S_IRUSR);
printf("Unclue file %s.\n", absfilename);
read_bytes=read(inp_file_d, tempchar,1);
bytesname=tempchar[0];
memset(tempchar,0,sizeof(tempchar));
read_bytes=read(inp_file_d, tempchar,bytesname);
//printf("%s.\n", tempchar);
long long tempbytes=0;
//sscanf(tempchar,"%lld",&tempbytes);
tempbytes=bytestoint(tempchar);
data_need_bytes=(size_t) tempbytes;
printf("%lld bytes.\n", (long long)data_need_bytes);
//printf("debug\n");
do {
if (BUF_SIZE<=data_need_bytes) {
read_bytes=read(inp_file_d, buffer,BUF_SIZE);
} else {
read_bytes=read(inp_file_d, buffer,data_need_bytes);
}
data_need_bytes-=read_bytes;
//printf("%s\n%lld\n",buffer,(long long)read_bytes);
written_bytes=write(out_file_d, buffer, read_bytes);
} while(data_need_bytes!=(size_t)0);
close(out_file_d);
printf("File %s unclued.\n", absfilename);
} while(1);
close(inp_file_d);
//closedir(dfd);
printf("Unclue operation is completed.\n");
} else {
printf ("Wrong second argument.\n");
}
}
return 0;
}
int main(int argc, char **argv) {
/* expect the first argument to be the dump file */
if (argc <= 1) {
printf("Usage: %s <dump.rdb>\n", argv[0]);
exit(0);
}
int fd;
off_t size;
struct stat stat;
void *data;
fd = open(argv[1], O_RDONLY);
if (fd < 1) {
ERROR("Cannot open file: %s\n", argv[1]);
}
if (fstat(fd, &stat) == -1) {
ERROR("Cannot stat: %s\n", argv[1]);
} else {
size = stat.st_size;
}
if (sizeof(size_t) == sizeof(int32_t) && size >= INT_MAX) {
ERROR("Cannot check dump files >2GB on a 32-bit platform\n");
}
data = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
if (data == MAP_FAILED) {
ERROR("Cannot mmap: %s\n", argv[1]);
}
/* Initialize static vars */
positions[0].data = data;
positions[0].size = size;
positions[0].offset = 0;
errors.level = 0;
/* Object types */
sprintf(types[REDIS_STRING], "STRING");
sprintf(types[REDIS_LIST], "LIST");
sprintf(types[REDIS_SET], "SET");
sprintf(types[REDIS_ZSET], "ZSET");
sprintf(types[REDIS_HASH], "HASH");
/* Object types only used for dumping to disk */
sprintf(types[REDIS_EXPIRETIME], "EXPIRETIME");
sprintf(types[REDIS_SELECTDB], "SELECTDB");
sprintf(types[REDIS_EOF], "EOF");
/* Double constants initialization */
R_Zero = 0.0;
R_PosInf = 1.0/R_Zero;
R_NegInf = -1.0/R_Zero;
R_Nan = R_Zero/R_Zero;
process();
munmap(data, size);
close(fd);
return 0;
}
int
main(int argc, char **argv)
{
int onlydir, dodir, dolink, dorelsymlink, dotimes, opt, len, lplen, tdlen, bnlen, exists, fromfd, tofd, cc, wc;
mode_t mode = 0755;
char *linkprefix, *owner, *group, *cp, *cwd, *todir, *toname, *name, *base, *linkname, *bp, buf[BUFSIZ];
uid_t uid;
gid_t gid;
struct stat sb, tosb;
struct utimbuf utb;
program = argv[0];
cwd = linkname = linkprefix = owner = group = 0;
onlydir = dodir = dolink = dorelsymlink = dotimes = lplen = 0;
while ((opt = getopt(argc, argv, "C:DdlL:Rm:o:g:t")) != EOF) {
switch (opt) {
case 'C':
cwd = optarg;
break;
case 'D':
onlydir = 1;
break;
case 'd':
dodir = 1;
break;
case 'l':
dolink = 1;
break;
case 'L':
linkprefix = optarg;
lplen = strlen(linkprefix);
dolink = 1;
break;
case 'R':
dolink = dorelsymlink = 1;
break;
case 'm':
mode = strtoul(optarg, &cp, 8);
if (mode == 0 && cp == optarg)
usage();
break;
case 'o':
owner = optarg;
break;
case 'g':
group = optarg;
break;
case 't':
dotimes = 1;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc < 2 - onlydir)
usage();
todir = argv[argc-1];
if ((stat(todir, &sb) < 0 || !S_ISDIR(sb.st_mode)) &&
mkdirs(todir, 0777) < 0) {
fail("cannot make directory %s", todir);
}
if (onlydir)
return 0;
if (!cwd) {
#ifdef GETCWD_CAN_MALLOC
cwd = getcwd(0, PATH_MAX);
#else
cwd = malloc(PATH_MAX + 1);
cwd = getcwd(cwd, PATH_MAX);
#endif
}
xchdir(todir);
#ifdef GETCWD_CAN_MALLOC
todir = getcwd(0, PATH_MAX);
#else
todir = malloc(PATH_MAX + 1);
todir = getcwd(todir, PATH_MAX);
#endif
tdlen = strlen(todir);
xchdir(cwd);
tdlen = strlen(todir);
uid = owner ? touid(owner) : -1;
gid = group ? togid(group) : -1;
while (--argc > 0) {
name = *argv++;
len = strlen(name);
base = xbasename(name);
bnlen = strlen(base);
toname = (char*)xmalloc(tdlen + 1 + bnlen + 1);
sprintf(toname, "%s/%s", todir, base);
exists = (lstat(toname, &tosb) == 0);
if (dodir) {
/* -d means create a directory, always */
if (exists && !S_ISDIR(tosb.st_mode)) {
(void) unlink(toname);
exists = 0;
}
if (!exists && mkdir(toname, mode) < 0)
fail("cannot make directory %s", toname);
if ((owner || group) && chown(toname, uid, gid) < 0)
fail("cannot change owner of %s", toname);
} else if (dolink) {
if (*name == '/') {
/* source is absolute pathname, link to it directly */
linkname = 0;
} else {
if (linkprefix) {
/* -L implies -l and prefixes names with a $cwd arg. */
len += lplen + 1;
linkname = (char*)xmalloc(len + 1);
sprintf(linkname, "%s/%s", linkprefix, name);
} else if (dorelsymlink) {
/* Symlink the relative path from todir to source name. */
linkname = (char*)xmalloc(PATH_MAX);
if (*todir == '/') {
/* todir is absolute: skip over common prefix. */
lplen = relatepaths(todir, cwd, linkname);
strcpy(linkname + lplen, name);
} else {
/* todir is named by a relative path: reverse it. */
reversepath(todir, name, len, linkname);
xchdir(cwd);
}
len = strlen(linkname);
}
name = linkname;
}
/* Check for a pre-existing symlink with identical content. */
if (exists &&
(!S_ISLNK(tosb.st_mode) ||
readlink(toname, buf, sizeof buf) != len ||
strncmp(buf, name, len) != 0)) {
(void) (S_ISDIR(tosb.st_mode) ? rmdir : unlink)(toname);
exists = 0;
}
if (!exists && symlink(name, toname) < 0)
fail("cannot make symbolic link %s", toname);
#ifdef HAVE_LCHOWN
if ((owner || group) && lchown(toname, uid, gid) < 0)
fail("cannot change owner of %s", toname);
#endif
if (linkname) {
free(linkname);
linkname = 0;
}
} else {
/* Copy from name to toname, which might be the same file. */
fromfd = open(name, O_RDONLY);
if (fromfd < 0 || fstat(fromfd, &sb) < 0)
fail("cannot access %s", name);
if (exists && (!S_ISREG(tosb.st_mode) || access(toname, W_OK) < 0))
(void) (S_ISDIR(tosb.st_mode) ? rmdir : unlink)(toname);
tofd = open(toname, O_CREAT | O_WRONLY, 0666);
if (tofd < 0)
fail("cannot create %s", toname);
bp = buf;
while ((cc = read(fromfd, bp, sizeof buf)) > 0) {
while ((wc = write(tofd, bp, cc)) > 0) {
if ((cc -= wc) == 0)
break;
bp += wc;
}
if (wc < 0)
fail("cannot write to %s", toname);
}
if (cc < 0)
fail("cannot read from %s", name);
if (ftruncate(tofd, sb.st_size) < 0)
fail("cannot truncate %s", toname);
if (dotimes) {
utb.actime = sb.st_atime;
utb.modtime = sb.st_mtime;
if (utime(toname, &utb) < 0)
fail("cannot set times of %s", toname);
}
#ifdef HAVE_FCHMOD
if (fchmod(tofd, mode) < 0)
#else
if (chmod(toname, mode) < 0)
#endif
fail("cannot change mode of %s", toname);
if ((owner || group) && fchown(tofd, uid, gid) < 0)
fail("cannot change owner of %s", toname);
/* Must check for delayed (NFS) write errors on close. */
if (close(tofd) < 0)
fail("cannot write to %s", toname);
close(fromfd);
}
free(toname);
}
free(cwd);
free(todir);
return 0;
}
int main(int argc, char *argv[])
{
// Read arguments
if (argc != 3) {
std::cout << "\nUsage: ./split_fastq <fastq_file> <nb_parts>\n\n";
return 1;
}
std::string fastq_file_name = argv[1];
int nb_parts = atoi(argv[2]);
std::string prefix = fastq_file_name.substr(0, fastq_file_name.rfind("."));
std::string ext = fastq_file_name.substr(fastq_file_name.rfind(".") + 1);
////////////////////////////////////////////////////////////////////////////
// Open and map the input file
//
// Open input file
int fdin = open (fastq_file_name.c_str(), O_RDONLY);
if (fdin < 0){
std::cerr << "can't open " << fastq_file_name << " for reading -> exit\n";
exit(1);
}
// find size of input file
struct stat statbuf;
if (fstat (fdin, &statbuf) < 0){
std::cerr << "fstat error on " << fastq_file_name << " -> exit\n";
exit(1);
}
// mmap the input file
char * src = (char *) mmap (0, statbuf.st_size, PROT_READ, MAP_SHARED, fdin, 0);
if (src == NULL){
std::cerr << "mmap error on " << fastq_file_name << " -> exit\n";
exit(1);
}
////////////////////////////////////////////////////////////////////////////
// Calculate the index of the beginning of each sub-file and its size
//
size_t sub_index [nb_parts];
size_t sub_size [nb_parts];
sub_index[0] = 0;
size_t default_size = statbuf.st_size / nb_parts;
for (int i = 1; i < nb_parts; i++) {
sub_index[i] = default_size;
while (sub_index[i] < statbuf.st_size) {
if (src[sub_index[i]] == '@' && src[sub_index[i] - 1] == '\n') {
break;
}
sub_index[i]++;
}
sub_size [i - 1] = sub_index[i] - sub_index[i - 1];
default_size += statbuf.st_size / nb_parts;
}
sub_size [nb_parts - 1] = statbuf.st_size - sub_index[nb_parts - 1];
////////////////////////////////////////////////////////////////////////////
// Open, map, and copy the output files
//
for (int i = 0; i < nb_parts; i++) {
std::stringstream output_file_name;
output_file_name << prefix << "_" << i + 1 << "." << ext;
// open/create the output file
int fdout = open (output_file_name.str().c_str(), O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600);
if (fdout < 0){
std::cerr << "can't create file number " << output_file_name.str() << " for writing-> exit\n";
exit(1);
}
// go to the location corresponding to the last byte
if (lseek (fdout, sub_size[i] - 1, SEEK_SET) == -1) {
std::cerr << "lseek error on " << output_file_name.str() << "-> exit\n";
exit(1);
}
// write a dummy byte at the last location
if (write (fdout, "", 1) != 1){
std::cerr << "write error on " << output_file_name.str() << "-> exit\n";
exit(1);
}
// mmap the output file
char * dst = (char *) mmap (0, sub_size[i], PROT_READ | PROT_WRITE, MAP_SHARED, fdout, 0);
if (dst == NULL) {
std::cerr << "mmap error on " << output_file_name.str() << "-> exit\n";
exit(1);
}
// copy the bunch of data
memcpy (dst, src + sub_index[i], sub_size[i]);
// unmap output file
if (munmap(dst, sub_size[i])){
std::cerr << "munmap error on " << output_file_name.str() << " -> exit\n";
}
// close output file
close (fdout);
}
// unmap input file
if (munmap(src, statbuf.st_size)){
std::cerr << "munmap error on " << fastq_file_name << " -> exit\n";
}
close (fdin);
return 0;
}
static void *image_create_v1(struct image_cfg_element *image_cfg,
int cfgn, const char *output, size_t *imagesz)
{
struct image_cfg_element *e, *payloade, *binarye;
struct main_hdr_v1 *main_hdr;
size_t headersz, payloadsz, totalsz;
void *image, *cur;
int hasext = 0;
int ret;
/* Calculate the size of the header and the size of the
* payload */
headersz = sizeof(struct main_hdr_v1);
payloadsz = 0;
if (image_count_options(image_cfg, cfgn, IMAGE_CFG_BINARY) > 1) {
fprintf(stderr, "More than one binary blob, not supported\n");
return NULL;
}
if (image_count_options(image_cfg, cfgn, IMAGE_CFG_PAYLOAD) > 1) {
fprintf(stderr, "More than one payload, not possible\n");
return NULL;
}
binarye = image_find_option(image_cfg, cfgn, IMAGE_CFG_BINARY);
if (binarye) {
struct stat s;
ret = stat(binarye->binary.file, &s);
if (ret < 0) {
char *cwd = get_current_dir_name();
fprintf(stderr,
"Didn't find the file '%s' in '%s' which is mandatory to generate the image\n"
"This file generally contains the DDR3 training code, and should be extracted from an existing bootable\n"
"image for your board. See 'kwbimage -x' to extract it from an existing image.\n",
binarye->binary.file, cwd);
free(cwd);
return NULL;
}
headersz += s.st_size +
binarye->binary.nargs * sizeof(unsigned int);
hasext = 1;
}
payloade = image_find_option(image_cfg, cfgn, IMAGE_CFG_PAYLOAD);
if (payloade) {
struct stat s;
ret = stat(payloade->payload, &s);
if (ret < 0) {
fprintf(stderr, "Cannot stat payload file %s\n",
payloade->payload);
return NULL;
}
/* payload size must be multiple of 32b */
payloadsz = 4 * ((s.st_size + 3)/4);
}
/* The payload should be aligned on some reasonable
* boundary */
headersz = ALIGN_SUP(headersz, 4096);
/* The total size includes the headers, the payload, and the
* 32 bits checksum at the end of the payload */
totalsz = headersz + payloadsz + sizeof(uint32_t);
image = malloc(totalsz);
if (!image) {
fprintf(stderr, "Cannot allocate memory for image\n");
return NULL;
}
memset(image, 0, totalsz);
cur = main_hdr = image;
cur += sizeof(struct main_hdr_v1);
/* Fill the main header */
main_hdr->blocksize = payloadsz + sizeof(uint32_t);
main_hdr->headersz_lsb = headersz & 0xFFFF;
main_hdr->headersz_msb = (headersz & 0xFFFF0000) >> 16;
main_hdr->srcaddr = headersz;
main_hdr->ext = hasext;
main_hdr->version = 1;
e = image_find_option(image_cfg, cfgn, IMAGE_CFG_BOOT_FROM);
if (e)
main_hdr->blockid = e->bootfrom;
e = image_find_option(image_cfg, cfgn, IMAGE_CFG_DEST_ADDR);
if (e)
main_hdr->destaddr = e->dstaddr;
e = image_find_option(image_cfg, cfgn, IMAGE_CFG_EXEC_ADDR);
if (e)
main_hdr->execaddr = e->execaddr;
e = image_find_option(image_cfg, cfgn, IMAGE_CFG_NAND_BLKSZ);
if (e)
main_hdr->nandblocksize = e->nandblksz / (64 * 1024);
e = image_find_option(image_cfg, cfgn, IMAGE_CFG_NAND_BADBLK_LOCATION);
if (e)
main_hdr->nandbadblklocation = e->nandbadblklocation;
if (binarye) {
struct opt_hdr_v1 *hdr = cur;
unsigned int *args;
size_t binhdrsz;
struct stat s;
int argi;
FILE *bin;
hdr->headertype = OPT_HDR_V1_BINARY_TYPE;
bin = fopen(binarye->binary.file, "r");
if (!bin) {
fprintf(stderr, "Cannot open binary file %s\n",
binarye->binary.file);
return NULL;
}
fstat(fileno(bin), &s);
binhdrsz = sizeof(struct opt_hdr_v1) +
(binarye->binary.nargs + 1) * sizeof(unsigned int) +
s.st_size;
hdr->headersz_lsb = binhdrsz & 0xFFFF;
hdr->headersz_msb = (binhdrsz & 0xFFFF0000) >> 16;
cur += sizeof(struct opt_hdr_v1);
args = cur;
*args = binarye->binary.nargs;
args++;
for (argi = 0; argi < binarye->binary.nargs; argi++)
args[argi] = binarye->binary.args[argi];
cur += (binarye->binary.nargs + 1) * sizeof(unsigned int);
ret = fread(cur, s.st_size, 1, bin);
if (ret != 1) {
fprintf(stderr,
"Could not read binary image %s\n",
binarye->binary.file);
return NULL;
}
fclose(bin);
cur += s.st_size;
/*
* For now, we don't support more than one binary
* header, and no other header types are
* supported. So, the binary header is necessarily the
* last one
*/
*((unsigned char *) cur) = 0;
cur += sizeof(uint32_t);
}
/* Calculate and set the header checksum */
main_hdr->checksum = image_checksum8(main_hdr, headersz);
if (payloade) {
ret = image_create_payload(image + headersz, payloadsz,
payloade->payload);
if (ret < 0)
return NULL;
}
*imagesz = totalsz;
return image;
}
static int
flopen_retry(const char *filename)
{
int fd, try;
for (try = 1; try <= 1024; try *= 2) {
fd = flopen(filename, PEFS_SESSION_FILE_FLAGS,
PEFS_SESSION_FILE_MODE);
if (fd != -1)
return (fd);
else if (errno != EWOULDBLOCK)
return (-1);
// Exponential back-off up to 1 second
usleep(try * 1000000 / 1024);
}
errno = ETIMEDOUT;
return (-1);
}
static int
pefs_session_count_incr(const char *user, bool incr)
{
struct stat sb;
struct timespec tp_uptime, tp_now;
ssize_t offset;
int fd, total = 0;
char filename[MAXPATHLEN], buf[16];
const char *errstr;
snprintf(filename, sizeof(filename), "%s/%s", PEFS_SESSION_DIR, user);
if (lstat(PEFS_SESSION_DIR, &sb) == -1) {
if (errno != ENOENT) {
pefs_warn("unable to access session directory %s: %s",
PEFS_SESSION_DIR, strerror(errno));
return (-1);
}
if (mkdir(PEFS_SESSION_DIR, PEFS_SESSION_DIR_MODE) == -1) {
pefs_warn("unable to create session directory %s: %s",
PEFS_SESSION_DIR, strerror(errno));
return (-1);
}
} else if (!S_ISDIR(sb.st_mode)) {
pefs_warn("%s is not a directory", PEFS_SESSION_DIR);
return (-1);
}
if ((fd = flopen_retry(filename)) == -1) {
pefs_warn("unable to create session counter file %s: %s",
filename, strerror(errno));
return (-1);
}
if ((offset = pread(fd, buf, sizeof(buf) - 1, 0)) == -1) {
pefs_warn("unable to read from the session counter file %s: %s",
filename, strerror(errno));
close(fd);
return (-1);
}
buf[offset] = '\0';
if (offset != 0) {
total = strtonum(buf, 0, INT_MAX, &errstr);
if (errstr != NULL)
pefs_warn("corrupted session counter file: %s: %s",
filename, errstr);
}
/*
* Determine if this is the first increment of the session file.
*
* It is considered the first increment if the session file has not
* been modified since the last boot time.
*/
if (incr && total > 0) {
if (fstat(fd, &sb) == -1) {
pefs_warn("unable to access session counter file %s: %s",
filename, strerror(errno));
close(fd);
return (-1);
}
/*
* Check is messy and will fail if wall clock isn't monotonical
* (e.g. because of ntp, DST, leap seconds)
*/
clock_gettime(CLOCK_REALTIME_FAST, &tp_now);
clock_gettime(CLOCK_UPTIME_FAST, &tp_uptime);
if (sb.st_mtime < tp_now.tv_sec - tp_uptime.tv_sec) {
pefs_warn("stale session counter file: %s",
filename);
total = 0;
}
}
lseek(fd, 0L, SEEK_SET);
ftruncate(fd, 0L);
total += incr ? 1 : -1;
if (total < 0) {
pefs_warn("corrupted session counter file: %s",
filename);
total = 0;
} else
pefs_warn("%s: session count %d", user, total);
buf[0] = '\0';
snprintf(buf, sizeof(buf), "%d", total);
pwrite(fd, buf, strlen(buf), 0);
close(fd);
return (total);
}
static int
pam_pefs_checkfs(const char *homedir)
{
char fsroot[MAXPATHLEN];
int error;
error = pefs_getfsroot(homedir, 0, fsroot, sizeof(fsroot));
if (error != 0) {
pefs_warn("file system is not mounted: %s", homedir);
return (PAM_USER_UNKNOWN);
} if (strcmp(fsroot, homedir) != 0) {
pefs_warn("file system is not mounted on home dir: %s", fsroot);
return (PAM_USER_UNKNOWN);
}
return (PAM_SUCCESS);
}
/* lines are written unmodified */
writeFile(fileStruct *fs, char *fName, int isNew)
{
FILE *fp;
lineStruct *ls, *ps;
int i, c, j, tabCnt, blankCnt, hadNonblank;
struct stat statbuf;
if( fs->ro && !isNew )
{
dingMsg("File is Read-Only");
return(0);
}
fp = fopen(fName, "w");
if( fp == NULL )
{
dingMsg("Failed to open file");
return(0);
}
fchmod(fileno(fp), fs->accessMode);
ps = NULL;
for(ls=fs->head; ls; ls=ls->next)
{
if( ps ) /* Was it a filler fake ? */
{
if( !(ls->flags & 1))
{ /* It was interim filler, put in the blank lines */
for( ; ps != ls; ps=ps->next)
putc('\n', fp);
ps = NULL;
}
}
if( ls->numCharsAvail == 0 )
{ /* On disk still, just copy from disk */
if( ls->flags & 1) /* A filler line */
{
if( !ps )
ps = ls;
}
else
{
fseek(fs->fp, ls->data.offset, SEEK_SET);
for(i=0; i<ls->numChars; i++)
if( (c=getc(fs->fp)) == EOF )
{
emsg("Unexpected EOF on read");
break;
}
else
putc(c, fp);
putc('\n', fp);
}
}
else
{
hadNonblank = blankCnt = 0;
for(i=0; i<ls->numChars; i++)
{
if( ls->data.line[i] == ' ' )
blankCnt++;
else
{
if( blankCnt )
{
if( hadNonblank == 0 )
{ /* no chars yet, convert as many as possible to tabs */
tabCnt = blankCnt / 8;
for(j = 0; j<tabCnt; j++)
putc('\t', fp);
blankCnt = blankCnt - tabCnt * 8;
}
for(j=0; j<blankCnt; j++)
putc(' ', fp);
blankCnt = 0;
}
hadNonblank = 1;
putc(ls->data.line[i], fp);
}
}
putc('\n', fp);
}
}
/* Every time we write, need to update the file info's inode info so */
/* a subsequent open does not create a new file entry */
if( fstat(fileno(fp), &statbuf) == 0 )
{
fs->devNo = statbuf.st_dev;
fs->inode = statbuf.st_ino;
}
fclose(fp);
return(1);
}
int
main(int argc, const char** argv)
{
if (argc < 7 or argc > 10) {
usageAndExit(argv[0]);
}
unsigned alignment = 1;
if (argc > 7) {
alignment = atoi(argv[7]);
}
bool writable = false;
bool executable = false;
for (int i = 8; i < argc; ++i) {
if (strcmp("writable", argv[i]) == 0) {
writable = true;
} else if (strcmp("executable", argv[i]) == 0) {
executable = true;
} else {
usageAndExit(argv[0]);
}
}
uint8_t* data = 0;
unsigned size;
int fd = open(argv[1], O_RDONLY);
if (fd != -1) {
struct stat s;
int r = fstat(fd, &s);
if (r != -1) {
#ifdef WIN32
HANDLE fm;
HANDLE h = (HANDLE) _get_osfhandle (fd);
fm = CreateFileMapping(
h,
NULL,
PAGE_READONLY,
0,
0,
NULL);
data = static_cast<uint8_t*>(MapViewOfFile(
fm,
FILE_MAP_READ,
0,
0,
s.st_size));
CloseHandle(fm);
#else
data = static_cast<uint8_t*>
(mmap(0, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0));
#endif
size = s.st_size;
}
close(fd);
}
bool success = false;
if (data) {
FileOutputStream out(argv[2]);
if (out.isValid()) {
success = writeObject
(data, size, &out, argv[3], argv[4], argv[5], argv[6], alignment,
writable, executable);
} else {
fprintf(stderr, "unable to open %s\n", argv[2]);
}
#ifdef WIN32
UnmapViewOfFile(data);
#else
munmap(data, size);
#endif
} else {
perror(argv[0]);
}
return (success ? 0 : -1);
}
static int save_external_coredump(
const char *context[_CONTEXT_MAX],
int input_fd,
char **ret_filename,
int *ret_node_fd,
int *ret_data_fd,
uint64_t *ret_size,
bool *ret_truncated) {
_cleanup_free_ char *fn = NULL, *tmp = NULL;
_cleanup_close_ int fd = -1;
uint64_t rlimit, process_limit, max_size;
struct stat st;
uid_t uid;
int r;
assert(context);
assert(ret_filename);
assert(ret_node_fd);
assert(ret_data_fd);
assert(ret_size);
r = parse_uid(context[CONTEXT_UID], &uid);
if (r < 0)
return log_error_errno(r, "Failed to parse UID: %m");
r = safe_atou64(context[CONTEXT_RLIMIT], &rlimit);
if (r < 0)
return log_error_errno(r, "Failed to parse resource limit '%s': %m", context[CONTEXT_RLIMIT]);
if (rlimit < page_size()) {
/* Is coredumping disabled? Then don't bother saving/processing the coredump.
* Anything below PAGE_SIZE cannot give a readable coredump (the kernel uses
* ELF_EXEC_PAGESIZE which is not easily accessible, but is usually the same as PAGE_SIZE. */
return log_info_errno(SYNTHETIC_ERRNO(EBADSLT),
"Resource limits disable core dumping for process %s (%s).",
context[CONTEXT_PID], context[CONTEXT_COMM]);
}
process_limit = MAX(arg_process_size_max, storage_size_max());
if (process_limit == 0)
return log_debug_errno(SYNTHETIC_ERRNO(EBADSLT),
"Limits for coredump processing and storage are both 0, not dumping core.");
/* Never store more than the process configured, or than we actually shall keep or process */
max_size = MIN(rlimit, process_limit);
r = make_filename(context, &fn);
if (r < 0)
return log_error_errno(r, "Failed to determine coredump file name: %m");
(void) mkdir_p_label("/var/lib/systemd/coredump", 0755);
fd = open_tmpfile_linkable(fn, O_RDWR|O_CLOEXEC, &tmp);
if (fd < 0)
return log_error_errno(fd, "Failed to create temporary file for coredump %s: %m", fn);
r = copy_bytes(input_fd, fd, max_size, 0);
if (r < 0) {
log_error_errno(r, "Cannot store coredump of %s (%s): %m", context[CONTEXT_PID], context[CONTEXT_COMM]);
goto fail;
}
*ret_truncated = r == 1;
if (*ret_truncated)
log_struct(LOG_INFO,
LOG_MESSAGE("Core file was truncated to %zu bytes.", max_size),
"SIZE_LIMIT=%zu", max_size,
"MESSAGE_ID=" SD_MESSAGE_TRUNCATED_CORE_STR);
if (fstat(fd, &st) < 0) {
log_error_errno(errno, "Failed to fstat core file %s: %m", coredump_tmpfile_name(tmp));
goto fail;
}
if (lseek(fd, 0, SEEK_SET) == (off_t) -1) {
log_error_errno(errno, "Failed to seek on %s: %m", coredump_tmpfile_name(tmp));
goto fail;
}
#if HAVE_XZ || HAVE_LZ4
/* If we will remove the coredump anyway, do not compress. */
if (arg_compress && !maybe_remove_external_coredump(NULL, st.st_size)) {
_cleanup_free_ char *fn_compressed = NULL, *tmp_compressed = NULL;
_cleanup_close_ int fd_compressed = -1;
fn_compressed = strappend(fn, COMPRESSED_EXT);
if (!fn_compressed) {
log_oom();
goto uncompressed;
}
fd_compressed = open_tmpfile_linkable(fn_compressed, O_RDWR|O_CLOEXEC, &tmp_compressed);
if (fd_compressed < 0) {
log_error_errno(fd_compressed, "Failed to create temporary file for coredump %s: %m", fn_compressed);
goto uncompressed;
}
r = compress_stream(fd, fd_compressed, -1);
if (r < 0) {
log_error_errno(r, "Failed to compress %s: %m", coredump_tmpfile_name(tmp_compressed));
goto fail_compressed;
}
r = fix_permissions(fd_compressed, tmp_compressed, fn_compressed, context, uid);
if (r < 0)
goto fail_compressed;
/* OK, this worked, we can get rid of the uncompressed version now */
if (tmp)
unlink_noerrno(tmp);
*ret_filename = TAKE_PTR(fn_compressed); /* compressed */
*ret_node_fd = TAKE_FD(fd_compressed); /* compressed */
*ret_data_fd = TAKE_FD(fd); /* uncompressed */
*ret_size = (uint64_t) st.st_size; /* uncompressed */
return 0;
fail_compressed:
if (tmp_compressed)
(void) unlink(tmp_compressed);
}
uncompressed:
#endif
r = fix_permissions(fd, tmp, fn, context, uid);
if (r < 0)
goto fail;
*ret_filename = TAKE_PTR(fn);
*ret_data_fd = TAKE_FD(fd);
*ret_node_fd = -1;
*ret_size = (uint64_t) st.st_size;
return 0;
fail:
if (tmp)
(void) unlink(tmp);
return r;
}
int rhizome_direct_form_received(rhizome_http_request *r)
{
const char *submitBareFileURI=confValueGet("rhizome.api.addfile.uri", NULL);
/* Process completed form based on the set of fields seen */
if (!strcmp(r->path,"/rhizome/import")) {
switch(r->fields_seen) {
case RD_MIME_STATE_MANIFESTHEADERS | RD_MIME_STATE_DATAHEADERS: {
/* Got a bundle to import */
DEBUGF("Call bundle import for rhizomedata.%d.{data,file}",
r->alarm.poll.fd);
strbuf manifest_path = strbuf_alloca(50);
strbuf payload_path = strbuf_alloca(50);
strbuf_sprintf(manifest_path, "rhizomedirect.%d.manifest", r->alarm.poll.fd);
strbuf_sprintf(payload_path, "rhizomedirect.%d.data", r->alarm.poll.fd);
int ret = rhizome_bundle_import_files(strbuf_str(manifest_path), strbuf_str(payload_path), 1); // ttl = 1
DEBUGF("Import returned %d",ret);
rhizome_direct_clear_temporary_files(r);
/* report back to caller.
200 = ok, which is probably appropriate for when we already had the bundle.
201 = content created, which is probably appropriate for when we successfully
import a bundle (or if we already have it).
403 = forbidden, which might be appropriate if we refuse to accept it, e.g.,
the import fails due to malformed data etc.
(should probably also indicate if we have a newer version if possible)
*/
switch (ret) {
case 0:
return rhizome_server_simple_http_response(r, 201, "Bundle succesfully imported.");
case 2:
return rhizome_server_simple_http_response(r, 200, "Bundle already imported.");
}
return rhizome_server_simple_http_response(r, 500, "Server error: Rhizome import command failed.");
}
break;
default:
/* Clean up after ourselves */
rhizome_direct_clear_temporary_files(r);
}
} else if (!strcmp(r->path,"/rhizome/enquiry")) {
int fd=-1;
char file[1024];
switch(r->fields_seen) {
case RD_MIME_STATE_DATAHEADERS:
/* Read data buffer in, pass to rhizome direct for comparison with local
rhizome database, and send back responses. */
snprintf(file,1024,"rhizomedirect.%d.%s",r->alarm.poll.fd,"data");
fd=open(file,O_RDONLY);
if (fd == -1) {
WHYF_perror("open(%s, O_RDONLY)", alloca_str_toprint(file));
/* Clean up after ourselves */
rhizome_direct_clear_temporary_files(r);
return rhizome_server_simple_http_response(r,500,"Couldn't read a file");
}
struct stat stat;
if (fstat(fd, &stat) == -1) {
WHYF_perror("stat(%d)", fd);
/* Clean up after ourselves */
close(fd);
rhizome_direct_clear_temporary_files(r);
return rhizome_server_simple_http_response(r,500,"Couldn't stat a file");
}
unsigned char *addr = mmap(NULL, stat.st_size, PROT_READ, MAP_SHARED, fd, 0);
if (addr==MAP_FAILED) {
WHYF_perror("mmap(NULL, %lld, PROT_READ, MAP_SHARED, %d, 0)", (long long) stat.st_size, fd);
/* Clean up after ourselves */
close(fd);
rhizome_direct_clear_temporary_files(r);
return rhizome_server_simple_http_response(r,500,"Couldn't mmap() a file");
}
/* Ask for a fill response. Regardless of the size of the set of BARs passed
to us, we will allow up to 64KB of response. */
rhizome_direct_bundle_cursor
*c=rhizome_direct_get_fill_response(addr,stat.st_size,65536);
munmap(addr,stat.st_size);
close(fd);
if (c)
{
/* TODO: Write out_buffer as the body of the response.
We should be able to do this using the async framework fairly easily.
*/
int bytes=c->buffer_offset_bytes+c->buffer_used;
r->buffer=malloc(bytes+1024);
r->buffer_size=bytes+1024;
r->buffer_offset=0;
assert(r->buffer);
/* Write HTTP response header */
struct http_response hr;
hr.result_code=200;
hr.content_type="binary/octet-stream";
hr.content_length=bytes;
hr.body=NULL;
r->request_type=0;
rhizome_server_set_response(r,&hr);
assert(r->buffer_offset<1024);
/* Now append body and send it back. */
bcopy(c->buffer,&r->buffer[r->buffer_length],bytes);
r->buffer_length+=bytes;
r->buffer_offset=0;
/* Clean up cursor after sending response */
rhizome_direct_bundle_iterator_free(&c);
/* Clean up after ourselves */
rhizome_direct_clear_temporary_files(r);
return 0;
}
else
{
return rhizome_server_simple_http_response(r,500,"Could not get response to enquiry");
}
/* Clean up after ourselves */
rhizome_direct_clear_temporary_files(r);
break;
default:
/* Clean up after ourselves */
rhizome_direct_clear_temporary_files(r);
return rhizome_server_simple_http_response(r, 404, "/rhizome/enquiry requires 'data' field");
}
}
/* Allow servald to be configured to accept files without manifests via HTTP
from localhost, so that rhizome bundles can be created programatically.
There are probably still some security loop-holes here, which is part of
why we leave it disabled by default, but it will be sufficient for testing
possible uses, including integration with OpenDataKit.
*/
else if (submitBareFileURI&&(!strcmp(r->path,submitBareFileURI))) {
if (strcmp(inet_ntoa(r->requestor.sin_addr),
confValueGet("rhizome.api.addfile.allowedaddress","127.0.0.1")))
{
DEBUGF("rhizome.api.addfile request received from %s, but is only allowed from %s",
inet_ntoa(r->requestor.sin_addr),
confValueGet("rhizome.api.addfile.allowedaddress", "127.0.0.1"));
rhizome_direct_clear_temporary_files(r);
return rhizome_server_simple_http_response(r,404,"Not available from here.");
}
switch(r->fields_seen) {
case RD_MIME_STATE_DATAHEADERS:
/* We have been given a file without a manifest, we should only
accept if it we are configured to do so, and the connection is from
localhost. Otherwise people could cause your servald to create
arbitrary bundles, which would be bad.
*/
/* A bundle to import */
DEBUGF("Call bundle import sans-manifest for rhizomedata.%d.{data,file}",
r->alarm.poll.fd);
char filepath[1024];
snprintf(filepath,1024,"rhizomedirect.%d.data",r->alarm.poll.fd);
const char *manifestTemplate
=confValueGet("rhizome.api.addfile.manifesttemplate", NULL);
if (manifestTemplate&&access(manifestTemplate, R_OK) != 0)
{
rhizome_direct_clear_temporary_files(r);
return rhizome_server_simple_http_response(r,500,"rhizome.api.addfile.manifesttemplate points to a file I could not read.");
}
rhizome_manifest *m = rhizome_new_manifest();
if (!m)
{
rhizome_server_simple_http_response(r,500,"No free manifest slots. Try again later.");
rhizome_direct_clear_temporary_files(r);
return WHY("Manifest struct could not be allocated -- not added to rhizome");
}
if (manifestTemplate)
if (rhizome_read_manifest_file(m, manifestTemplate, 0) == -1) {
rhizome_manifest_free(m);
rhizome_direct_clear_temporary_files(r);
return rhizome_server_simple_http_response(r,500,"rhizome.api.addfile.manifesttemplate can't be read as a manifest.");
}
/* Fill in a few missing manifest fields, to make it easier to use when adding new files:
- the default service is FILE
- use the current time for "date"
- if service is file, then use the payload file's basename for "name"
*/
const char *service = rhizome_manifest_get(m, "service", NULL, 0);
if (service == NULL) {
rhizome_manifest_set(m, "service", (service = RHIZOME_SERVICE_FILE));
if (debug & DEBUG_RHIZOME) DEBUGF("missing 'service', set default service=%s", service);
} else {
if (debug & DEBUG_RHIZOME) DEBUGF("manifest contains service=%s", service);
}
if (rhizome_manifest_get(m, "date", NULL, 0) == NULL) {
rhizome_manifest_set_ll(m, "date", (long long) gettime_ms());
if (debug & DEBUG_RHIZOME) DEBUGF("missing 'date', set default date=%s", rhizome_manifest_get(m, "date", NULL, 0));
}
const char *name = rhizome_manifest_get(m, "name", NULL, 0);
if (name == NULL) {
name=r->data_file_name;
rhizome_manifest_set(m, "name", r->data_file_name);
if (debug & DEBUG_RHIZOME) DEBUGF("missing 'name', set name=\"%s\" from HTTP post field filename specification", name);
} else {
if (debug & DEBUG_RHIZOME) DEBUGF("manifest contains name=\"%s\"", name);
}
const char *senderhex
= rhizome_manifest_get(m, "sender", NULL, 0);
if (!senderhex) senderhex=confValueGet("rhizome.api.addfile.author",NULL);
unsigned char authorSid[SID_SIZE];
if (senderhex) fromhexstr(authorSid,senderhex,SID_SIZE);
const char *bskhex
=confValueGet("rhizome.api.addfile.bundlesecretkey", NULL);
/* Bind an ID to the manifest, and also bind the file. Then finalise the
manifest. But if the manifest already contains an ID, don't override it. */
if (rhizome_manifest_get(m, "id", NULL, 0) == NULL) {
if (rhizome_manifest_bind_id(m, senderhex ? authorSid : NULL)) {
rhizome_manifest_free(m);
m = NULL;
rhizome_direct_clear_temporary_files(r);
return rhizome_server_simple_http_response(r,500,"Could not bind manifest to an ID");
}
} else if (bskhex) {
/* Allow user to specify a bundle secret key so that the same bundle can
be updated, rather than creating a new bundle each time. */
unsigned char bsk[RHIZOME_BUNDLE_KEY_BYTES];
fromhexstr(bsk,bskhex,RHIZOME_BUNDLE_KEY_BYTES);
memcpy(m->cryptoSignSecret, bsk, RHIZOME_BUNDLE_KEY_BYTES);
if (rhizome_verify_bundle_privatekey(m) == -1) {
rhizome_manifest_free(m);
m = NULL;
rhizome_direct_clear_temporary_files(r);
return rhizome_server_simple_http_response(r,500,"rhizome.api.addfile.bundlesecretkey did not verify. Using the right key for the right bundle?");
}
} else {
/* Bundle ID specified, but without a BSK or sender SID specified.
Therefore we cannot work out the bundle key, and cannot update the
bundle. */
rhizome_manifest_free(m);
m = NULL;
rhizome_direct_clear_temporary_files(r);
return rhizome_server_simple_http_response(r,500,"rhizome.api.addfile.bundlesecretkey not set, and manifest template contains no sender, but template contains a hard-wired bundle ID. You must specify at least one, or not supply id= in the manifest template.");
}
int encryptP = 0; // TODO Determine here whether payload is to be encrypted.
if (rhizome_manifest_bind_file(m, filepath, encryptP)) {
rhizome_manifest_free(m);
rhizome_direct_clear_temporary_files(r);
return rhizome_server_simple_http_response(r,500,"Could not bind manifest to file");
}
if (rhizome_manifest_finalise(m)) {
rhizome_manifest_free(m);
rhizome_direct_clear_temporary_files(r);
return rhizome_server_simple_http_response(r,500,
"Could not finalise manifest");
}
if (rhizome_add_manifest(m,255 /* TTL */)) {
rhizome_manifest_free(m);
rhizome_direct_clear_temporary_files(r);
return rhizome_server_simple_http_response(r,500,
"Add manifest operation failed");
}
DEBUGF("Import sans-manifest appeared to succeed");
/* Respond with the manifest that was added. */
rhizome_server_simple_http_response(r, 200, (char *)m->manifestdata);
/* clean up after ourselves */
rhizome_manifest_free(m);
rhizome_direct_clear_temporary_files(r);
return 0;
break;
default:
/* Clean up after ourselves */
rhizome_direct_clear_temporary_files(r);
return rhizome_server_simple_http_response(r, 400, "Rhizome create bundle from file API requires 'data' field");
}
}
/* Clean up after ourselves */
rhizome_direct_clear_temporary_files(r);
/* Report error */
return rhizome_server_simple_http_response(r, 500, "Something went wrong. Probably a missing data or manifest part, or invalid combination of URI and data/manifest provision.");
}
/**
* @brief Extract and gunzip the linux kernel\n
* Configure :\n
* LIBKERNSH_CONFIG_KERNEL, LIBKERNSH_CONFIG_STORAGE_PATH, LIBKERNSH_CONFIG_KERNELGZ, LIBKERNSH_CONFIG_KERNELELF, LIBKERNSH_CONFIG_OBJCOPY, LIBKERNSH_CONFIG_GZIP
* @return 0 on success, -1 on error
*/
int kernsh_decompkernel_linux()
{
char magic[] = { 0x1f, 0x8b, 0x08 };
char buf[256];
char bufgz[256];
char bufelf[256];
char decomp[256];
struct stat st;
int fd, fz;
int size;
char *begin, *zone;
PROFILER_IN(__FILE__, __FUNCTION__, __LINE__);
#if __DEBUG_KERNSH__
printf("DECOMP KERNEL LINUX\n");
#endif
XOPEN(fd,
(char *) config_get_data(LIBKERNSH_CONFIG_KERNEL),
O_RDONLY,
0,
-1);
#if __DEBUG_KERNSH__
printf("OPEN KERNEL @ %s\n", (char *) config_get_data(LIBKERNSH_CONFIG_KERNEL));
#endif
if(fstat(fd, &st) == -1)
{
PROFILER_ERR(__FILE__, __FUNCTION__, __LINE__, "fd error", -1);
}
#if defined(__linux__)
XMMAP(zone, NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0, -1);
#endif
#if __DEBUG_KERNSH__
printf("MMAP size %d @ 0x%lx\n", (int)st.st_size, (unsigned long) zone);
#endif
begin = kernsh_find_pattern(zone, st.st_size, magic, 3);
#if __DEBUG_KERNSH__
printf("FIND MAGIC GZIP PATTERN @ 0x%lx\n", (unsigned long) begin);
#endif
size = st.st_size - ((int)begin - (int)zone);
memset(buf, '\0', sizeof(buf));
snprintf(buf, sizeof(buf), "%s%s",
(char *) config_get_data(LIBKERNSH_CONFIG_STORAGE_PATH),
(char *) config_get_data(LIBKERNSH_CONFIG_KERNELGZ));
XOPEN(fz, buf, O_CREAT|O_RDWR, 0777, -1);
#if __DEBUG_KERNSH__
printf("OPEN GZ KERNEL @ %s\n", buf);
#endif
XWRITE(fz, begin, size, -1);
XCLOSE(fz, -1);
#if defined(__linux__)
XMUNMAP(zone, st.st_size, -1);
#endif
XCLOSE(fd, -1);
memset(decomp, '\0', sizeof(decomp));
snprintf(decomp, sizeof(decomp), "%s -d -f %s%s",
(char *) config_get_data(LIBKERNSH_CONFIG_GZIP),
(char *) config_get_data(LIBKERNSH_CONFIG_STORAGE_PATH),
(char *) config_get_data(LIBKERNSH_CONFIG_KERNELGZ));
#if __DEBUG_KERNSH__
printf("DECOMP %s\n", decomp);
#endif
system(decomp);
memset(bufgz, '\0', sizeof(bufgz));
snprintf(bufgz, sizeof(bufgz), "%s%s",
(char *) config_get_data(LIBKERNSH_CONFIG_STORAGE_PATH),
(char *) config_get_data(LIBKERNSH_CONFIG_KERNELGZ));
bufgz[strlen(bufgz) - 3] = '\0';
memset(bufelf, '\0', sizeof(bufelf));
snprintf(bufelf, sizeof(bufelf), "%s%s",
(char *) config_get_data(LIBKERNSH_CONFIG_STORAGE_PATH),
(char *) config_get_data(LIBKERNSH_CONFIG_KERNELELF));
memset(buf, '\0', sizeof(buf));
snprintf(buf, sizeof(buf) , "%s -B i386 -I binary -O elf32-i386 %s %s",
(char *) config_get_data(LIBKERNSH_CONFIG_OBJCOPY),
bufgz,
bufelf);
#if __DEBUG_KERNSH__
printf("EXTRACT ELF FROM DATA @ %s%s\n", (char *) config_get_data(LIBKERNSH_CONFIG_STORAGE_PATH), (char *) config_get_data(LIBKERNSH_CONFIG_KERNELELF));
#endif
system(buf);
PROFILER_ROUT(__FILE__, __FUNCTION__, __LINE__, 0);
}
static void ps_files_open(ps_files *data, const char *key)
{
char buf[MAXPATHLEN];
#if !defined(O_NOFOLLOW) || !defined(PHP_WIN32)
struct stat sbuf;
#endif
int ret;
if (data->fd < 0 || !data->lastkey || strcmp(key, data->lastkey)) {
if (data->lastkey) {
efree(data->lastkey);
data->lastkey = NULL;
}
ps_files_close(data);
if (php_session_valid_key(key) == FAILURE) {
php_error_docref(NULL, E_WARNING, "The session id is too long or contains illegal characters, valid characters are a-z, A-Z, 0-9 and '-,'");
return;
}
if (!ps_files_path_create(buf, sizeof(buf), data, key)) {
php_error_docref(NULL, E_WARNING, "Failed to create session data file path. Too short session ID, invalid save_path or path lentgth exceeds MAXPATHLEN(%d)", MAXPATHLEN);
return;
}
data->lastkey = estrdup(key);
/* O_NOFOLLOW to prevent us from following evil symlinks */
#ifdef O_NOFOLLOW
data->fd = VCWD_OPEN_MODE(buf, O_CREAT | O_RDWR | O_BINARY | O_NOFOLLOW, data->filemode);
#else
/* Check to make sure that the opened file is not outside of allowable dirs.
This is not 100% safe but it's hard to do something better without O_NOFOLLOW */
if(PG(open_basedir) && lstat(buf, &sbuf) == 0 && S_ISLNK(sbuf.st_mode) && php_check_open_basedir(buf)) {
return;
}
data->fd = VCWD_OPEN_MODE(buf, O_CREAT | O_RDWR | O_BINARY, data->filemode);
#endif
if (data->fd != -1) {
#ifndef PHP_WIN32
/* check that this session file was created by us or root – we
don't want to end up accepting the sessions of another webapp */
if (fstat(data->fd, &sbuf) || (sbuf.st_uid != 0 && sbuf.st_uid != getuid() && sbuf.st_uid != geteuid())) {
close(data->fd);
data->fd = -1;
php_error_docref(NULL, E_WARNING, "Session data file is not created by your uid");
return;
}
#endif
do {
ret = flock(data->fd, LOCK_EX);
} while (ret == -1 && errno == EINTR);
#ifdef F_SETFD
# ifndef FD_CLOEXEC
# define FD_CLOEXEC 1
# endif
if (fcntl(data->fd, F_SETFD, FD_CLOEXEC)) {
php_error_docref(NULL, E_WARNING, "fcntl(%d, F_SETFD, FD_CLOEXEC) failed: %s (%d)", data->fd, strerror(errno), errno);
}
#endif
} else {
php_error_docref(NULL, E_WARNING, "open(%s, O_RDWR) failed: %s (%d)", buf, strerror(errno), errno);
}
}
}
void Fstat(int fd, struct stat *buf)
{
if (fstat(fd, buf) < 0)
unix_error("Fstat error");
}
static int flash_bml_partition(const MtdPartition* pSrcPart, const MtdPartition* pReservoirPart,
const unsigned short* blockMapping, const char* filename)
{
int fd = open(filename, O_RDONLY);
if (fd < 0)
{
fprintf(stderr, "error opening %s", filename);
return -1;
}
BmlOverMtdWriteContext* pSrcWrite = bml_over_mtd_write_partition(pSrcPart);
if (pSrcWrite == NULL)
{
close(fd);
fprintf(stderr, "flash_bml_partition: Error opening src part for writing.\n");
return -1;
}
#ifdef DUMMY_WRITING
close(pSrcWrite->fd);
pSrcWrite->fd = open("/sdcard/srcPartWriteDummy.bin", O_WRONLY|O_CREAT|O_TRUNC, 0666);
#endif
BmlOverMtdWriteContext* pResWrite = bml_over_mtd_write_partition(pReservoirPart);
if (pResWrite == NULL)
{
close(fd);
bml_over_mtd_write_close(pSrcWrite);
fprintf(stderr, "flash_bml_partition: Error opening reservoir part for writing.\n");
return -1;
}
#ifdef DUMMY_WRITING
close(pResWrite->fd);
pResWrite->fd = open("/sdcard/resPartWriteDummy.bin", O_WRONLY|O_CREAT|O_TRUNC, 0666);
#endif
struct stat fileStat;
if (fstat(fd, &fileStat) != 0)
{
close(fd);
bml_over_mtd_write_close(pSrcWrite);
bml_over_mtd_write_close(pResWrite);
fprintf(stderr, "flash_bml_partition: Failed to stat source file.\n");
return -1;
}
if (fileStat.st_size > pSrcPart->size)
{
close(fd);
bml_over_mtd_write_close(pSrcWrite);
bml_over_mtd_write_close(pResWrite);
fprintf(stderr, "flash_bml_partition: Source file too large for target partition.\n");
return -1;
}
int numBlocks = (fileStat.st_size + pSrcPart->erase_size - 1) / pSrcPart->erase_size;
int currblock;
for (currblock = 0 ; currblock < numBlocks; ++currblock)
{
memset(pSrcWrite->buffer, 0xFF, pSrcPart->erase_size);
size_t blockBytesRead = 0;
while (blockBytesRead < pSrcPart->erase_size)
{
ssize_t len = read(fd, pSrcWrite->buffer + blockBytesRead,
pSrcPart->erase_size - blockBytesRead);
if (len < 0)
{
close(fd);
bml_over_mtd_write_close(pSrcWrite);
bml_over_mtd_write_close(pResWrite);
fprintf(stderr, "flash_bml_partition: read source file failed\n");
return -1;
}
if (len == 0)
{
//End of file
break;
}
blockBytesRead += len;
}
int srcFd = -1;
if (blockMapping[currblock] == 0xffff)
{
//Good block, use src partition
srcFd = pSrcWrite->fd;
if (lseek64(pSrcWrite->fd, currblock*pSrcPart->erase_size, SEEK_SET)==-1)
{
close(fd);
bml_over_mtd_write_close(pSrcWrite);
bml_over_mtd_write_close(pResWrite);
fprintf(stderr, "flash_bml_partition: lseek in src partition failed\n");
return -1;
}
} else
{
//Bad block, use mapped block in reservoir partition
srcFd = pResWrite->fd;
if (lseek64(pResWrite->fd, blockMapping[currblock]*pSrcPart->erase_size, SEEK_SET)==-1)
{
close(fd);
bml_over_mtd_write_close(pSrcWrite);
bml_over_mtd_write_close(pResWrite);
fprintf(stderr, "flash_bml_partition: lseek in reservoir partition failed\n");
return -1;
}
}
size_t blockBytesWritten = 0;
while (blockBytesWritten < pSrcPart->erase_size)
{
#ifdef DUMMY_WRITING
ssize_t len = write(srcFd, pSrcWrite->buffer + blockBytesWritten,
pSrcPart->erase_size - blockBytesWritten);
#else
ssize_t len = bml_over_mtd_write_block(srcFd, pSrcPart->erase_size, pSrcWrite->buffer);
#endif
if (len <= 0)
{
close(fd);
bml_over_mtd_write_close(pSrcWrite);
bml_over_mtd_write_close(pResWrite);
fprintf(stderr, "flash_bml_partition: writing to partition failed\n");
return -1;
}
blockBytesWritten += len;
}
}
bml_over_mtd_write_close(pSrcWrite);
bml_over_mtd_write_close(pResWrite);
if (close(fd)) {
printf("error closing %s", filename);
return -1;
}
return 0;
}
/* compress or decompress from stdin to stdout */
int main(int argc, char **argv)
{
int rc = Z_OK;
bool compress = true;
int list_contents = 0;
bool force = false;
bool quiet __attribute__((unused)) = false;
int window_bits = 31; /* GZIP */
int level = Z_DEFAULT_COMPRESSION;
char *prog = basename(argv[0]);
const char *in_f = NULL;
char out_f[PATH_MAX];
FILE *i_fp = stdin;
FILE *o_fp = NULL;
const char *suffix = "gz";
int force_software = 0;
int cpu = -1;
unsigned char *in = NULL;
unsigned char *out = NULL;
z_stream strm;
const char *name = NULL;
char *comment = NULL;
const char *extra_fname = NULL;
uint8_t *extra = NULL;
int extra_len = 0;
struct stat s;
const char *accel = "GENWQE";
const char *accel_env = getenv("ZLIB_ACCELERATOR");
int card_no = 0;
const char *card_no_env = getenv("ZLIB_CARD");
/* Use environment variables as defaults. Command line options
can than overrule this. */
if (accel_env != NULL)
accel = accel_env;
if (card_no_env != NULL)
card_no = atoi(card_no_env);
/* avoid end-of-line conversions */
SET_BINARY_MODE(stdin);
SET_BINARY_MODE(stdout);
if (strstr(prog, "gunzip") != 0)
compress = false;
while (1) {
int ch;
int option_index = 0;
static struct option long_options[] = {
{ "stdout", no_argument, NULL, 'c' },
{ "decompress", no_argument, NULL, 'd' },
{ "force", no_argument, NULL, 'f' },
{ "help", no_argument, NULL, 'h' },
/* list */
{ "list", no_argument, NULL, 'l' },
{ "license", no_argument, NULL, 'L' },
{ "suffix", required_argument, NULL, 'S' },
{ "verbose", no_argument, NULL, 'v' },
{ "version", no_argument, NULL, 'V' },
{ "fast", no_argument, NULL, '1' },
{ "best", no_argument, NULL, '9' },
/* our own options */
{ "cpu", required_argument, NULL, 'X' },
{ "accelerator-type", required_argument, NULL, 'A' },
{ "card_no", required_argument, NULL, 'B' },
{ "software", no_argument, NULL, 's' },
{ "extra", required_argument, NULL, 'E' },
{ "name", required_argument, NULL, 'N' },
{ "comment", required_argument, NULL, 'C' },
{ "i_bufsize", required_argument, NULL, 'i' },
{ "o_bufsize", required_argument, NULL, 'o' },
{ 0, no_argument, NULL, 0 },
};
ch = getopt_long(argc, argv,
"E:N:C:cdfqhlLsS:vV123456789?i:o:X:A:B:",
long_options, &option_index);
if (ch == -1) /* all params processed ? */
break;
switch (ch) {
case 'X':
cpu = strtoul(optarg, NULL, 0);
break;
case 'A':
accel = optarg;
break;
case 'B':
card_no = strtol(optarg, (char **)NULL, 0);
break;
case 'E':
extra_fname = optarg;
break;
case 'N':
name = optarg;
break;
case 'C':
comment = optarg;
break;
case 'd':
compress = false;
break;
case 'f':
force = true;
break;
case 'q':
/* Currently does nothing, zless needs it */
quiet = true;
break;
case 'c':
o_fp = stdout;
break;
case 'S':
suffix = optarg;
break;
case 's':
force_software = true;
break;
case 'l':
list_contents++;
break;
case '1':
level = Z_BEST_SPEED;
break;
case '2':
level = 2;
break;
case '3':
level = 3;
break;
case '4':
level = 4;
break;
case '5':
level = 5;
break;
case '6':
level = 6;
break;
case '7':
level = 7;
break;
case '8':
level = 8;
break;
case '9':
level = Z_BEST_COMPRESSION;
break;
case 'v':
verbose++;
break;
case 'V':
fprintf(stdout, "%s\n", version);
exit(EXIT_SUCCESS);
break;
case 'i':
CHUNK_i = str_to_num(optarg);
break;
case 'o':
CHUNK_o = str_to_num(optarg);
break;
case 'L':
userinfo(stdout, prog, version);
exit(EXIT_SUCCESS);
break;
case 'h':
case '?':
usage(stdout, prog, argc, argv);
exit(EXIT_SUCCESS);
break;
}
}
if (cpu != -1)
pin_to_cpu(cpu);
if (force_software) {
zlib_set_inflate_impl(ZLIB_SW_IMPL);
zlib_set_deflate_impl(ZLIB_SW_IMPL);
} else {
zlib_set_accelerator(accel, card_no);
zlib_set_inflate_impl(ZLIB_HW_IMPL);
zlib_set_deflate_impl(ZLIB_HW_IMPL);
}
/* FIXME loop over this ... */
if (optind < argc) { /* input file */
in_f = argv[optind++];
i_fp = fopen(in_f, "r");
if (!i_fp) {
pr_err("%s\n", strerror(errno));
print_args(stderr, argc, argv);
exit(EX_ERRNO);
}
rc = lstat(in_f, &s);
if ((rc == 0) && S_ISLNK(s.st_mode)) {
pr_err("%s: Too many levels of symbolic links\n",
in_f);
exit(EXIT_FAILURE);
}
if (list_contents) {
rc = strip_ending(out_f, in_f, PATH_MAX, suffix);
if (rc < 0) {
pr_err("No .%s file!\n", suffix);
print_args(stderr, argc, argv);
exit(EXIT_FAILURE);
}
rc = do_list_contents(i_fp, out_f, list_contents);
if (rc != 0) {
pr_err("Unable to list contents.\n");
print_args(stderr, argc, argv);
exit(EXIT_FAILURE);
}
fclose(i_fp);
exit(EXIT_SUCCESS);
}
}
if (in_f == NULL)
o_fp = stdout; /* should not be a terminal! */
if (o_fp == NULL) {
if (compress)
snprintf(out_f, PATH_MAX, "%s.%s", in_f, suffix);
else {
rc = strip_ending(out_f, in_f, PATH_MAX, suffix);
if (rc < 0) {
pr_err("No .%s file!\n", suffix);
print_args(stderr, argc, argv);
exit(EXIT_FAILURE);
}
}
rc = stat(out_f, &s);
if (!force && (rc == 0)) {
pr_err("File %s already exists!\n", out_f);
print_args(stderr, argc, argv);
exit(EX_ERRNO);
}
o_fp = fopen(out_f, "w+");
if (!o_fp) {
pr_err("Cannot open output file %s: %s\n", out_f,
strerror(errno));
print_args(stderr, argc, argv);
exit(EX_ERRNO);
}
/* get mode settings for existing file and ... */
rc = fstat(fileno(i_fp), &s);
if (rc == 0) {
rc = fchmod(fileno(o_fp), s.st_mode);
if (rc != 0) {
pr_err("Cannot set mode %s: %s\n", out_f,
strerror(errno));
exit(EX_ERRNO);
}
} else /* else ignore ... */
pr_err("Cannot set mode %s: %s\n", out_f,
strerror(errno));
/* If output does not go to stdout and a filename is
given, set it */
if (name == NULL)
name = in_f;
}
if (isatty(fileno(o_fp))) {
pr_err("Output must not be a terminal!\n");
print_args(stderr, argc, argv);
exit(EXIT_FAILURE);
}
if (optind != argc) { /* now it must fit */
usage(stderr, prog, argc, argv);
exit(EXIT_FAILURE);
}
in = malloc(CHUNK_i); /* This is the bigger Buffer by default */
if (NULL == in) {
pr_err("%s\n", strerror(errno));
print_args(stderr, argc, argv);
exit(EXIT_FAILURE);
}
out = malloc(CHUNK_o); /* This is the smaller Buffer by default */
if (NULL == out) {
pr_err("%s\n", strerror(errno));
print_args(stderr, argc, argv);
exit(EXIT_FAILURE);
}
/* allocate inflate state */
memset(&strm, 0, sizeof(strm));
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
if (compress) {
gz_header head;
struct timeval tv;
if (extra_fname) {
extra_len = file_size(extra_fname);
if (extra_len <= 0) {
rc = extra_len;
goto err_out;
}
extra = malloc(extra_len);
if (extra == NULL) {
rc = -ENOMEM;
goto err_out;
}
rc = file_read(extra_fname, extra, extra_len);
if (rc != 1) {
fprintf(stderr, "err: Unable to read extra "
"data rc=%d\n", rc);
free(extra);
goto err_out;
}
hexdump(stderr, extra, extra_len);
}
/* --------------- DEFALTE ----------------- */
rc = deflateInit2(&strm, level, Z_DEFLATED, window_bits, 8,
Z_DEFAULT_STRATEGY);
if (Z_OK != rc)
goto err_out;
memset(&head, 0, sizeof(head));
gettimeofday(&tv, NULL);
head.time = tv.tv_sec;
head.os = 0x03;
if (extra != NULL) {
head.extra = extra;
head.extra_len = extra_len;
head.extra_max = extra_len;
}
if (comment != NULL) {
head.comment = (Bytef *)comment;
head.comm_max = strlen(comment) + 1;
}
if (name != NULL) {
head.name = (Bytef *)name;
head.name_max = strlen(name) + 1;
}
rc = deflateSetHeader(&strm, &head);
if (Z_OK != rc) {
fprintf(stderr, "err: Cannot set gz header! rc=%d\n",
rc);
deflateEnd(&strm);
goto err_out;
}
/* do compression if no arguments */
rc = def(i_fp, o_fp, &strm, in, out);
if (Z_OK != rc)
zerr(rc);
if (extra != NULL)
free(extra);
deflateEnd(&strm);
} else {
/* --------------- INFALTE ----------------- */
strm.avail_in = 0;
strm.next_in = Z_NULL;
rc = inflateInit2(&strm, window_bits);
if (Z_OK != rc)
goto err_out;
do {
rc = inf(i_fp, o_fp, &strm, in, out);
if (Z_STREAM_END != rc) {
zerr(rc);
break;
}
} while (!feof(i_fp) && !ferror(i_fp));
inflateEnd(&strm);
}
err_out:
/* Delete the input file, only if input is not stdin and if
output is not stdout */
if ((rc == EXIT_SUCCESS) && (i_fp != stdin) && (o_fp != stdout)) {
rc = unlink(in_f);
if (rc != 0) {
pr_err("%s\n", strerror(errno));
print_args(stderr, argc, argv);
exit(EXIT_FAILURE);
}
}
fclose(i_fp);
fclose(o_fp);
free(in);
free(out);
exit(rc);
}
/*
** Given a file descriptor, locate lockInfo and openCnt structures that
** describes that file descriptor. Create a new ones if necessary. The
** return values might be unset if an error occurs.
**
** Return the number of errors.
*/
static int findLockInfo(
int fd, /* The file descriptor used in the key */
struct lockInfo **ppLock, /* Return the lockInfo structure here */
struct openCnt **ppOpen /* Return the openCnt structure here */
){
int rc;
struct lockKey key1;
struct openKey key2;
struct stat statbuf;
struct lockInfo *pLock;
struct openCnt *pOpen;
rc = fstat(fd, &statbuf);
if( rc!=0 ) return 1;
memset(&key1, 0, sizeof(key1));
key1.dev = statbuf.st_dev;
key1.ino = statbuf.st_ino;
#ifdef SQLITE_UNIX_THREADS
if( threadsOverrideEachOthersLocks<0 ){
testThreadLockingBehavior(fd);
}
key1.tid = threadsOverrideEachOthersLocks ? 0 : pthread_self();
#endif
memset(&key2, 0, sizeof(key2));
key2.dev = statbuf.st_dev;
key2.ino = statbuf.st_ino;
pLock = (struct lockInfo*)sqlite3HashFind(&lockHash, &key1, sizeof(key1));
if( pLock==0 ){
struct lockInfo *pOld;
pLock = (lockInfo*)sqliteMallocRaw( sizeof(*pLock) );
if( pLock==0 ) return 1;
pLock->key = key1;
pLock->nRef = 1;
pLock->cnt = 0;
pLock->locktype = 0;
pOld = (lockInfo*)sqlite3HashInsert(&lockHash, &pLock->key, sizeof(key1), pLock);
if( pOld!=0 ){
assert( pOld==pLock );
sqliteFree(pLock);
return 1;
}
}else{
pLock->nRef++;
}
*ppLock = pLock;
pOpen = (struct openCnt*)sqlite3HashFind(&openHash, &key2, sizeof(key2));
if( pOpen==0 ){
struct openCnt *pOld;
pOpen = (openCnt*)sqliteMallocRaw( sizeof(*pOpen) );
if( pOpen==0 ){
releaseLockInfo(pLock);
return 1;
}
pOpen->key = key2;
pOpen->nRef = 1;
pOpen->nLock = 0;
pOpen->nPending = 0;
pOpen->aPending = 0;
pOld = (openCnt*)sqlite3HashInsert(&openHash, &pOpen->key, sizeof(key2), pOpen);
if( pOld!=0 ){
assert( pOld==pOpen );
sqliteFree(pOpen);
releaseLockInfo(pLock);
return 1;
}
}else{
pOpen->nRef++;
}
*ppOpen = pOpen;
return 0;
}
static void dig_holes(int fd, off_t off, off_t len)
{
off_t end = len ? off + len : 0;
off_t hole_start = 0, hole_sz = 0;
uintmax_t ct = 0;
size_t bufsz;
char *buf;
struct stat st;
#if defined(POSIX_FADV_SEQUENTIAL) && defined(HAVE_POSIX_FADVISE)
off_t cache_start = off;
/*
* We don't want to call POSIX_FADV_DONTNEED to discard cached
* data in PAGE_SIZE steps. IMHO it's overkill (too many syscalls).
*
* Let's assume that 1MiB (on system with 4K page size) is just
* a good compromise.
* -- kzak Feb-2014
*/
const size_t cachesz = getpagesize() * 256;
#endif
if (fstat(fd, &st) != 0)
err(EXIT_FAILURE, _("stat of %s failed"), filename);
bufsz = st.st_blksize;
if (lseek(fd, off, SEEK_SET) < 0)
err(EXIT_FAILURE, _("seek on %s failed"), filename);
/* buffer + extra space for is_nul() sentinel */
buf = xmalloc(bufsz + sizeof(uintptr_t));
#if defined(POSIX_FADV_SEQUENTIAL) && defined(HAVE_POSIX_FADVISE)
posix_fadvise(fd, off, 0, POSIX_FADV_SEQUENTIAL);
#endif
while (end == 0 || off < end) {
ssize_t rsz;
rsz = pread(fd, buf, bufsz, off);
if (rsz < 0 && errno)
err(EXIT_FAILURE, _("%s: read failed"), filename);
if (end && rsz > 0 && off > end - rsz)
rsz = end - off;
if (rsz <= 0)
break;
if (is_nul(buf, rsz)) {
if (!hole_sz) { /* new hole detected */
int rc = skip_hole(fd, &off);
if (rc == 0)
continue; /* hole skipped */
else if (rc == 1)
break; /* end of file */
hole_start = off;
}
hole_sz += rsz;
} else if (hole_sz) {
xfallocate(fd, FALLOC_FL_PUNCH_HOLE|FALLOC_FL_KEEP_SIZE,
hole_start, hole_sz);
ct += hole_sz;
hole_sz = hole_start = 0;
}
#if defined(POSIX_FADV_DONTNEED) && defined(HAVE_POSIX_FADVISE)
/* discard cached data */
if (off - cache_start > (off_t) cachesz) {
size_t clen = off - cache_start;
clen = (clen / cachesz) * cachesz;
posix_fadvise(fd, cache_start, clen, POSIX_FADV_DONTNEED);
cache_start = cache_start + clen;
}
#endif
off += rsz;
}
if (hole_sz) {
xfallocate(fd, FALLOC_FL_PUNCH_HOLE|FALLOC_FL_KEEP_SIZE,
hole_start, hole_sz);
ct += hole_sz;
}
free(buf);
if (verbose) {
char *str = size_to_human_string(SIZE_SUFFIX_3LETTER | SIZE_SUFFIX_SPACE, ct);
fprintf(stdout, _("%s: %s (%ju bytes) converted to sparse holes.\n"),
filename, str, ct);
free(str);
}
}
/*
* rm_overwrite --
* Overwrite the file 3 times with varying bit patterns.
*
* XXX
* This is a cheap way to *really* delete files. Note that only regular
* files are deleted, directories (and therefore names) will remain.
* Also, this assumes a fixed-block file system (like FFS, or a V7 or a
* System V file system). In a logging or COW file system, you'll have to
* have kernel support.
*/
static int
rm_overwrite(const char *file, struct stat *sbp)
{
struct stat sb, sb2;
struct statfs fsb;
off_t len;
int bsize, fd, wlen;
char *buf = NULL;
fd = -1;
if (sbp == NULL) {
if (lstat(file, &sb))
goto err;
sbp = &sb;
}
if (!S_ISREG(sbp->st_mode))
return (1);
if (sbp->st_nlink > 1 && !fflag) {
warnx("%s (inode %ju): not overwritten due to multiple links",
file, (uintmax_t)sbp->st_ino);
return (0);
}
if ((fd = open(file, O_WRONLY|O_NONBLOCK|O_NOFOLLOW, 0)) == -1)
goto err;
if (fstat(fd, &sb2))
goto err;
if (sb2.st_dev != sbp->st_dev || sb2.st_ino != sbp->st_ino ||
!S_ISREG(sb2.st_mode)) {
errno = EPERM;
goto err;
}
if (fstatfs(fd, &fsb) == -1)
goto err;
bsize = MAX(fsb.f_iosize, 1024);
if ((buf = malloc(bsize)) == NULL)
err(1, "%s: malloc", file);
#define PASS(byte) { \
memset(buf, byte, bsize); \
for (len = sbp->st_size; len > 0; len -= wlen) { \
wlen = len < bsize ? len : bsize; \
if (write(fd, buf, wlen) != wlen) \
goto err; \
} \
}
PASS(0xff);
if (fsync(fd) || lseek(fd, (off_t)0, SEEK_SET))
goto err;
PASS(0x00);
if (fsync(fd) || lseek(fd, (off_t)0, SEEK_SET))
goto err;
PASS(0xff);
if (!fsync(fd) && !close(fd)) {
free(buf);
return (1);
}
err: eval = 1;
if (buf)
free(buf);
if (fd != -1)
close(fd);
warn("%s", file);
return (0);
}
/*
* elf to a.out converter for freebsd/sparc64 bootblocks.
*/
int
main(int ac, char **av)
{
Elf64_Half phentsize;
Elf64_Half machine;
Elf64_Half phnum;
Elf64_Xword filesz;
Elf64_Xword memsz;
Elf64_Addr entry;
Elf64_Off offset;
Elf64_Off phoff;
Elf64_Word type;
unsigned char data;
struct stat sb;
struct exec a;
Elf64_Phdr *p;
Elf64_Ehdr *e;
void *v;
int efd;
int fd;
int c;
int i;
fd = STDIN_FILENO;
while ((c = getopt(ac, av, "o:")) != -1)
switch (c) {
case 'o':
if ((fd = open(optarg, O_CREAT|O_RDWR, 0644)) < 0)
err(1, "%s", optarg);
break;
case '?':
default:
usage();
}
ac -= optind;
av += optind;
if (ac == 0)
usage();
if ((efd = open(*av, O_RDONLY)) < 0 || fstat(efd, &sb) < 0)
err(1, NULL);
v = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, efd, 0);
if ((e = v) == MAP_FAILED)
err(1, NULL);
if (!IS_ELF(*e))
errx(1, "not an elf file");
if (e->e_ident[EI_CLASS] != ELFCLASS64)
errx(1, "wrong class");
data = e->e_ident[EI_DATA];
if (data != ELFDATA2MSB && data != ELFDATA2LSB)
errx(1, "wrong data format");
if (e->e_ident[EI_VERSION] != EV_CURRENT)
errx(1, "wrong elf version");
machine = xe16toh(e->e_machine);
if (machine != EM_SPARCV9 && machine != EM_ALPHA)
errx(1, "wrong machine type");
phentsize = xe16toh(e->e_phentsize);
if (phentsize != sizeof(*p))
errx(1, "phdr size mismatch");
entry = xe64toh(e->e_entry);
phoff = xe64toh(e->e_phoff);
phnum = xe16toh(e->e_phnum);
p = (Elf64_Phdr *)((char *)e + phoff);
bzero(&a, sizeof(a));
for (i = 0; i < phnum; i++) {
type = xe32toh(p[i].p_type);
switch (type) {
case PT_LOAD:
if (a.a_magic != 0)
errx(1, "too many loadable segments");
filesz = xe64toh(p[i].p_filesz);
memsz = xe64toh(p[i].p_memsz);
offset = xe64toh(p[i].p_offset);
a.a_magic = htoxe32(A_MAGIC);
a.a_text = htoxe32(filesz);
a.a_bss = htoxe32(memsz - filesz);
a.a_entry = htoxe32(entry);
if (write(fd, &a, sizeof(a)) != sizeof(a) ||
write(fd, (char *)e + offset, filesz) != (ssize_t)filesz)
err(1, NULL);
break;
default:
break;
}
}
return (0);
}
static int
file_contents_equal(const char *path1, const char *path2, ino_t *path2_inode_r)
{
struct stat st1, st2;
int fd1, fd2, ret = -1;
*path2_inode_r = 0;
/* do a byte-by-byte comparison for the files to find out if they're
the same or if this is a hash collision */
fd1 = open(path1, O_RDONLY);
if (fd1 == -1) {
if (errno != ENOENT)
i_error("open(%s) failed: %m", path1);
return -1;
}
fd2 = open(path2, O_RDONLY);
if (fd1 == -1) {
if (errno != ENOENT)
i_error("open(%s) failed: %m", path2);
i_close_fd(&fd1);
return -1;
}
if (fstat(fd1, &st1) < 0)
i_error("fstat(%s) failed: %m", path1);
else if (fstat(fd2, &st2) < 0)
i_error("fstat(%s) failed: %m", path1);
else if (st1.st_size != st2.st_size)
ret = 0;
else {
/* @UNSAFE: sizes match. compare. */
unsigned char buf1[IO_BLOCK_SIZE], buf2[IO_BLOCK_SIZE];
ssize_t ret1;
int ret2;
while ((ret1 = read(fd1, buf1, sizeof(buf1))) > 0) {
if ((ret2 = read_full(fd2, buf2, ret1)) <= 0) {
if (ret2 < 0)
i_error("read(%s) failed: %m", path2);
else
ret = 0;
break;
}
if (memcmp(buf1, buf2, ret1) != 0) {
ret = 0;
break;
}
}
if (ret1 < 0)
i_error("read(%s) failed: %m", path1);
else if (ret1 == 0)
ret = 1;
*path2_inode_r = st2.st_ino;
}
if (close(fd1) < 0)
i_error("close(%s) failed: %m", path1);
if (close(fd2) < 0)
i_error("close(%s) failed: %m", path2);
return ret;
}
static PHP_METHOD(swoole_coroutine_util, fread)
{
coro_check(TSRMLS_C);
zval *handle;
zend_long length = 0;
#ifdef FAST_ZPP
ZEND_PARSE_PARAMETERS_START(1, 2)
Z_PARAM_RESOURCE(handle)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(length)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
#else
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &handle, &length) == FAILURE)
{
return;
}
#endif
int fd = swoole_convert_to_fd(handle TSRMLS_CC);
struct stat file_stat;
if (fstat(fd, &file_stat) < 0)
{
RETURN_FALSE;
}
off_t _seek = lseek(fd, 0, SEEK_CUR);
if (length <= 0 || file_stat.st_size - _seek < length)
{
length = file_stat.st_size - _seek;
}
swAio_event ev;
bzero(&ev, sizeof(swAio_event));
ev.nbytes = length + 1;
ev.buf = emalloc(ev.nbytes);
if (!ev.buf)
{
RETURN_FALSE;
}
php_context *context = emalloc(sizeof(php_context));
((char *) ev.buf)[length] = 0;
ev.flags = 0;
ev.type = SW_AIO_READ;
ev.object = context;
ev.callback = aio_onReadCompleted;
ev.fd = fd;
ev.offset = _seek;
if (!SwooleAIO.init)
{
php_swoole_check_reactor();
swAio_init();
}
swTrace("fd=%d, offset=%ld, length=%ld", fd, ev.offset, ev.nbytes);
int ret = swAio_dispatch(&ev);
if (ret < 0)
{
efree(context);
RETURN_FALSE;
}
context->onTimeout = NULL;
context->state = SW_CORO_CONTEXT_RUNNING;
coro_save(context);
coro_yield();
}
int main(int argc, char *argv[]) {
int fd;
char * fdata;
char * fname;
struct stat finfo;
long i;
// Make sure a filename is specified
if (argv[1] == NULL)
{
printf("USAGE: %s <filename>\n", argv[0]);
exit(1);
}
fname = argv[1];
printf("Linear Regression Serial: Running...\n");
// Read in the file
CHECK_ERROR((fd = open(fname, O_RDONLY)) < 0);
// Get the file info (for file length)
CHECK_ERROR(fstat(fd, &finfo) < 0);
// Memory map the file
CHECK_ERROR((fdata = mmap(0, finfo.st_size + 1,
PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0)) == NULL);
POINT_T *points = (POINT_T*)fdata;
long long n = (long long) finfo.st_size / sizeof(POINT_T);
long long SX_ll = 0, SY_ll = 0, SXX_ll = 0, SYY_ll = 0, SXY_ll = 0;
// ADD UP RESULTS
for (i = 0; i < n; i++)
{
//Compute SX, SY, SYY, SXX, SXY
SX_ll += points[i].x;
SXX_ll += points[i].x*points[i].x;
SY_ll += points[i].y;
SYY_ll += points[i].y*points[i].y;
SXY_ll += points[i].x*points[i].y;
}
double a, b, xbar, ybar, r2;
double SX = (double)SX_ll;
double SY = (double)SY_ll;
double SXX= (double)SXX_ll;
double SYY= (double)SYY_ll;
double SXY= (double)SXY_ll;
b = (double)(n*SXY - SX*SY) / (n*SXX - SX*SX);
a = (SY_ll - b*SX_ll) / n;
xbar = (double)SX_ll / n;
ybar = (double)SY_ll / n;
r2 = (double)(n*SXY - SX*SY) * (n*SXY - SX*SY) / ((n*SXX - SX*SX)*(n*SYY - SY*SY));
printf("Linear Regression Serial Results:\n");
printf("\ta = %lf\n", a);
printf("\tb = %lf\n", b);
printf("\txbar = %lf\n", xbar);
printf("\tybar = %lf\n", ybar);
printf("\tr2 = %lf\n", r2);
printf("\tSX = %lld\n", SX_ll);
printf("\tSY = %lld\n", SY_ll);
printf("\tSXX = %lld\n", SXX_ll);
printf("\tSYY = %lld\n", SYY_ll);
printf("\tSXY = %lld\n", SXY_ll);
CHECK_ERROR(munmap(fdata, finfo.st_size + 1) < 0);
CHECK_ERROR(close(fd) < 0);
return 0;
}
static int image_extract(const char *input, const char *output)
{
int fdi, ret;
struct stat fdistat, fdostat;
void *fdimap;
char *focfgname;
FILE *focfg;
fdi = open(input, O_RDONLY);
if (fdi < 0) {
fprintf(stderr, "Cannot open input file %s: %m\n",
input);
return -1;
}
ret = fstat(fdi, &fdistat);
if (ret < 0) {
fprintf(stderr, "Cannot stat input file %s: %m\n",
input);
close(fdi);
return -1;
}
fdimap = mmap(NULL, fdistat.st_size, PROT_READ, MAP_PRIVATE, fdi, 0);
if (fdimap == MAP_FAILED) {
fprintf(stderr, "Cannot map input file %s: %m\n",
input);
close(fdi);
return -1;
}
close(fdi);
ret = stat(output, &fdostat);
if (ret < 0) {
fprintf(stderr, "Cannot stat output directory %s: %m\n",
output);
munmap(fdimap, fdistat.st_size);
return -1;
}
if (!S_ISDIR(fdostat.st_mode)) {
fprintf(stderr, "Output %s should be a directory\n",
output);
munmap(fdimap, fdistat.st_size);
return -1;
}
ret = asprintf(&focfgname, "%s/kwbimage.cfg", output);
if (ret < 0) {
fprintf(stderr, "Failed to allocate memory\n");
munmap(fdimap, fdistat.st_size);
return -1;
}
focfg = fopen(focfgname, "w+");
if (!focfg) {
fprintf(stderr, "Output file %s could not be created\n",
focfgname);
free(focfgname);
munmap(fdimap, fdistat.st_size);
return -1;
}
free(focfgname);
if (image_version(fdimap) == 0)
ret = image_extract_v0(fdimap, output, focfg);
else if (image_version(fdimap) == 1)
ret = image_extract_v1(fdimap, output, focfg);
else {
fprintf(stderr, "Invalid image version %d\n",
image_version(fdimap));
ret = -1;
}
fclose(focfg);
munmap(fdimap, fdistat.st_size);
return ret;
}
static int acl_backend_vfile_acllist_read(struct acl_backend_vfile *backend)
{
struct acl_backend_vfile_acllist acllist;
struct istream *input;
struct stat st;
const char *path, *line, *p;
int fd, ret = 0;
backend->acllist_last_check = ioloop_time;
if (!acl_list_get_path(backend, &path)) {
/* we're never going to build acllist for this namespace. */
acllist_clear(backend, 0);
return 0;
}
if (backend->acllist_mtime != 0) {
/* see if the file's mtime has changed */
if (stat(path, &st) < 0) {
if (errno == ENOENT)
backend->acllist_mtime = 0;
else
i_error("stat(%s) failed: %m", path);
return -1;
}
if (st.st_mtime == backend->acllist_mtime)
return 0;
}
fd = open(path, O_RDONLY);
if (fd == -1) {
if (errno == ENOENT) {
backend->acllist_mtime = 0;
return -1;
}
i_error("open(%s) failed: %m", path);
return -1;
}
if (fstat(fd, &st) < 0) {
i_error("fstat(%s) failed: %m", path);
i_close_fd(&fd);
return -1;
}
backend->acllist_mtime = st.st_mtime;
acllist_clear(backend, st.st_size);
input = i_stream_create_fd(fd, (size_t)-1, FALSE);
while ((line = i_stream_read_next_line(input)) != NULL) {
acllist.mtime = 0;
for (p = line; *p >= '0' && *p <= '9'; p++)
acllist.mtime = acllist.mtime * 10 + (*p - '0');
if (p == line || *p != ' ' || p[1] == '\0') {
i_error("Broken acllist file: %s", path);
if (unlink(path) < 0 && errno != ENOENT)
i_error("unlink(%s) failed: %m", path);
i_close_fd(&fd);
return -1;
}
acllist.name = p_strdup(backend->acllist_pool, p + 1);
array_append(&backend->acllist, &acllist, 1);
}
if (input->stream_errno != 0)
ret = -1;
i_stream_destroy(&input);
if (close(fd) < 0)
i_error("close(%s) failed: %m", path);
return ret;
}
static int writeTarFile(const int tar_fd, const int verboseFlag,
const unsigned long dereferenceFlag, const llist_t *include,
const llist_t *exclude, const int gzip)
{
pid_t gzipPid = 0;
int errorFlag = FALSE;
struct TarBallInfo tbInfo;
tbInfo.hlInfoHead = NULL;
fchmod(tar_fd, 0644);
tbInfo.tarFd = tar_fd;
tbInfo.verboseFlag = verboseFlag;
/* Store the stat info for the tarball's file, so
* can avoid including the tarball into itself.... */
if (fstat(tbInfo.tarFd, &tbInfo.statBuf) < 0)
bb_perror_msg_and_die("cannot stat tar file");
if ((ENABLE_FEATURE_TAR_GZIP || ENABLE_FEATURE_TAR_BZIP2) && gzip) {
int gzipDataPipe[2] = { -1, -1 };
int gzipStatusPipe[2] = { -1, -1 };
volatile int vfork_exec_errno = 0;
const char *zip_exec = (gzip == 1) ? "gzip" : "bzip2";
if (pipe(gzipDataPipe) < 0 || pipe(gzipStatusPipe) < 0)
bb_perror_msg_and_die("pipe");
signal(SIGPIPE, SIG_IGN); /* we only want EPIPE on errors */
#if defined(__GNUC__) && __GNUC__
/* Avoid vfork clobbering */
(void) &include;
(void) &errorFlag;
(void) &zip_exec;
#endif
gzipPid = vfork();
if (gzipPid == 0) {
dup2(gzipDataPipe[0], 0);
close(gzipDataPipe[1]);
dup2(tbInfo.tarFd, 1);
close(gzipStatusPipe[0]);
fcntl(gzipStatusPipe[1], F_SETFD, FD_CLOEXEC); /* close on exec shows success */
BB_EXECLP(zip_exec, zip_exec, "-f", NULL);
vfork_exec_errno = errno;
close(gzipStatusPipe[1]);
exit(-1);
} else if (gzipPid > 0) {
close(gzipDataPipe[0]);
close(gzipStatusPipe[1]);
while (1) {
char buf;
int n = full_read(gzipStatusPipe[0], &buf, 1);
if (n == 0 && vfork_exec_errno != 0) {
errno = vfork_exec_errno;
bb_perror_msg_and_die("cannot exec %s", zip_exec);
} else if ((n < 0) && (errno == EAGAIN || errno == EINTR))
continue; /* try it again */
break;
}
close(gzipStatusPipe[0]);
tbInfo.tarFd = gzipDataPipe[1];
} else bb_perror_msg_and_die("vfork gzip");
}
tbInfo.excludeList = exclude;
/* Read the directory/files and iterate over them one at a time */
while (include) {
if (!recursive_action(include->data, TRUE, dereferenceFlag,
FALSE, writeFileToTarball, writeFileToTarball, &tbInfo, 0))
{
errorFlag = TRUE;
}
include = include->link;
}
/* Write two empty blocks to the end of the archive */
memset(bb_common_bufsiz1, 0, 2*TAR_BLOCK_SIZE);
xwrite(tbInfo.tarFd, bb_common_bufsiz1, 2*TAR_BLOCK_SIZE);
/* To be pedantically correct, we would check if the tarball
* is smaller than 20 tar blocks, and pad it if it was smaller,
* but that isn't necessary for GNU tar interoperability, and
* so is considered a waste of space */
/* Close so the child process (if any) will exit */
close(tbInfo.tarFd);
/* Hang up the tools, close up shop, head home */
if (ENABLE_FEATURE_CLEAN_UP)
freeHardLinkInfo(&tbInfo.hlInfoHead);
if (errorFlag)
bb_error_msg("error exit delayed from previous errors");
if (gzipPid) {
int status;
if (waitpid(gzipPid, &status, 0) == -1)
bb_perror_msg("waitpid");
else if (!WIFEXITED(status) || WEXITSTATUS(status))
/* gzip was killed or has exited with nonzero! */
errorFlag = TRUE;
}
return errorFlag;
}
static int load(const char *pszImage)
{
#ifdef RT_OS_WINDOWS
HANDLE hFile = CreateFile(pszImage,
GENERIC_READ,
FILE_SHARE_READ,
NULL /*pSecurityAttributes*/,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL /*hTemplateFile*/);
if (hFile == INVALID_HANDLE_VALUE)
{
printf("error: CreateFile('%s',): %d\n", pszImage, GetLastError());
return 1;
}
DWORD cbHigh = 0;
DWORD cbLow = GetFileSize(hFile, &cbHigh);
size_t cbFile = cbLow != INVALID_FILE_SIZE
? cbHigh == 0
? cbLow
: ~(DWORD)0 / 4
: 64;
HANDLE hMap = CreateFileMapping(hFile,
NULL /*pAttributes*/,
PAGE_READONLY | SEC_COMMIT,
0 /*dwMaximumSizeHigh -> file size*/,
0 /*dwMaximumSizeLow -> file size*/,
NULL /*pName*/);
if (hMap == INVALID_HANDLE_VALUE)
printf("error: CreateFile('%s',): %d\n", pszImage, GetLastError());
CloseHandle(hFile);
if (hMap == INVALID_HANDLE_VALUE)
return 1;
void *pvWhere = MapViewOfFile(hMap,
FILE_MAP_READ,
0 /*dwFileOffsetHigh*/,
0 /*dwFileOffsetLow*/,
0 /*dwNumberOfBytesToMap - file size */);
if (!pvWhere)
{
printf("error: MapViewOfView('%s',): %d\n", pszImage, GetLastError());
CloseHandle(hMap);
return 1;
}
#else
int fd = open(pszImage, O_RDONLY, 0);
if (fd < 0)
{
printf("error: open('%s',): %d\n", pszImage, errno);
return 1;
}
struct stat st;
memset(&st, 0, sizeof(st));
if (fstat(fd, &st))
st.st_size = 64;
size_t cbFile = st.st_size < ~(size_t)0
? (size_t)st.st_size
: ~(size_t)0 / 4;
void *pvWhere = mmap(NULL /*addr*/, cbFile, PROT_READ, MAP_FILE | MAP_PRIVATE, fd, 0 /*offset*/);
if (pvWhere == MAP_FAILED)
printf("error: mmap(,%lu,)/'%s': %d\n", (unsigned long)cbFile, pszImage, errno);
close(fd);
if (pvWhere == MAP_FAILED)
return 1;
#endif
/* Touch the whole image... do a dummy crc to keep the optimizer from begin
smart with us. */
unsigned char *puchFile = (unsigned char *)pvWhere;
size_t off = 0;
unsigned int uCrc = 0;
while (off < cbFile)
uCrc += puchFile[off++];
printf("info: %p/%#lx/%#x - %s\n", pvWhere, (unsigned long)cbFile, (unsigned char)uCrc, pszImage);
return 0;
}
void Application::compute(void *)
{
//
// ...... do work here ........
//
// read input parameters and data object name
int ofp;
char *address;
int length;
struct stat My_stat_buf;
err_status = Covise::get_browser_param("path", &Path);
IvDescr = Covise::get_object_name("descr");
count++;
#ifdef _WIN32
if ((ofp = Covise::open(Path, _O_RDONLY)) == -1)
#else
if ((ofp = Covise::open(Path, O_RDONLY)) == -1)
#endif
{
Covise::sendError("ERROR: Can't open file >> ");
return;
}
if (fstat(ofp, &My_stat_buf) < 0)
{
Covise::sendError("ERROR: Can't access file :");
return;
}
length = (int)My_stat_buf.st_size;
if (IvDescr != NULL)
{
descr = new coDoText(IvDescr, length);
if (descr->objectOk())
{
descr->getAddress(&address);
int n = read(ofp, address, length);
if (n != length)
{
fprintf(stderr, "ReadIv: compute(): short read\n");
}
}
else
{
Covise::sendError("ERROR: object name not correct for 'Iv-File'");
return;
}
}
else
{
Covise::sendError("ERROR: creation of data object 'descr' failed");
return;
}
delete descr;
close(ofp);
}
/**
* FIXME Verbose mode missing yet.
*/
static int do_list_contents(FILE *fp, char *out_f, int list_contents)
{
int rc;
struct stat st;
uint32_t d, crc32, size, compressed_size;
float ratio = 0.0;
z_stream strm;
uint8_t in[4096];
uint8_t out[4096];
gz_header head;
uint8_t extra[64 * 1024];
uint8_t comment[1024];
uint8_t name[1024];
int window_bits = 31; /* GZIP */
const char *mon[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
rc = fstat(fileno(fp), &st);
if (rc != 0)
return rc;
memset(&strm, 0, sizeof(strm));
strm.avail_in = 0;
strm.next_in = Z_NULL;
rc = inflateInit2(&strm, window_bits);
if (Z_OK != rc)
return rc;
strm.next_out = out;
strm.avail_out = sizeof(out);
strm.next_in = in;
strm.avail_in = fread(in, 1, sizeof(in), fp);
if (ferror(fp))
return Z_ERRNO;
head.extra = extra;
head.extra_len = 0;
head.extra_max = sizeof(extra);
head.comment = comment;
head.comm_max = sizeof(comment);
head.name = name;
head.name_max = sizeof(name);
rc = inflateGetHeader(&strm, &head);
if (Z_OK != rc) {
fprintf(stderr, "err: Cannot read gz header! rc=%d\n", rc);
return rc;
}
rc = inflate(&strm, Z_BLOCK);
if (Z_OK != rc) {
fprintf(stderr, "err: inflate(Z_BLOCK) failed rc=%d\n", rc);
return rc;
}
if (head.done == 0) {
fprintf(stderr, "err: gzip header not entirely decoded! "
"total_in=%ld total_out=%ld head.done=%d\n",
strm.total_in, strm.total_out, head.done);
return Z_DATA_ERROR;
}
rc = fseek(fp, st.st_size - 2 * sizeof(uint32_t), SEEK_SET);
if (rc != 0)
return rc;
rc = fread(&d, sizeof(d), 1, fp);
if (rc != 1)
return -1;
crc32 = __le32_to_cpu(d);
rc = fread(&d, sizeof(d), 1, fp);
if (rc != 1)
return -1;
size = __le32_to_cpu(d);
/* Compressed size is total file size reduced by gzip header
size and 8 bytes for the gzip trailer. */
compressed_size = st.st_size - strm.total_in - 8;
if (size)
ratio = 100 - (float)compressed_size * 100 / size;
if (!verbose) {
fprintf(stderr,
" compressed uncompressed ratio "
"uncompressed_name\n"
"%19lld %19d %2.2f%% %s\n",
(long long)st.st_size, size, ratio,
out_f);
} else {
time_t t = time(NULL);
struct tm *tm = localtime(&t);
/* (const time_t *)&head.time */
fprintf(stderr, "method crc date time "
"compressed uncompressed ratio "
"uncompressed_name\n"
"%s %x %s %2d %d:%d %19lld %19d %2.2f%% %s\n",
"defla", crc32,
mon[tm->tm_mon], tm->tm_mday, tm->tm_hour, tm->tm_min,
(long long)st.st_size, size, ratio,
out_f);
}
if (list_contents > 1)
do_print_gzip_hdr(&head, stderr);
return 0;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% W r i t e E P T I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method WriteEPTImage writes an image in the Adobe Encapsulated Postscript
% format with a TIFF preview.
%
% The format of the WriteEPTImage method is:
%
% unsigned int WriteEPTImage(const ImageInfo *image_info,Image *image)
%
% A description of each parameter follows.
%
% o status: Method WriteEPTImage return True if the image is written.
% False is returned is there is a memory shortage or if the image file
% fails to write.
%
% o image_info: Specifies a pointer to an ImageInfo structure.
%
% o image: A pointer to a Image structure.
%
%
*/
Export unsigned int WriteEPTImage(const ImageInfo *image_info,Image *image)
{
char
filename[MaxTextExtent];
FILE
*ps_file,
*tiff_file;
int
c;
unsigned int
status;
unsigned long
eps_length,
tiff_length;
ps_file=(FILE *) NULL;
if (Latin1Compare(image_info->magick,"PS") == 0)
ps_file=fopen(image->magick_filename,ReadBinaryType);
if (ps_file != (FILE *) NULL)
{
struct stat
attributes;
/*
Read existing Encapsulated Postscript.
*/
eps_length=
fstat(fileno(ps_file),&attributes) < 0 ? 0 : attributes.st_size;
}
else
{
/*
Write image as Encapsulated Postscript to a temporary file.
*/
(void) strcpy(filename,image->filename);
TemporaryFilename(image->filename);
status=WritePSImage(image_info,image);
if (status == False)
return(status);
status=OpenBlob(image_info,image,ReadBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
(void) remove(image->filename);
eps_length=image->filesize;
ps_file=image->file;
image->file=(FILE *) NULL;
}
/*
Write image as TIFF to a temporary file.
*/
TemporaryFilename(image->filename);
status=WriteTIFFImage(image_info,image);
if (status == False)
return(status);
status=OpenBlob(image_info,image,ReadBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
(void) remove(image->filename);
tiff_length=image->filesize;
tiff_file=image->file;
image->file=(FILE *) NULL;
/*
Write EPT image.
*/
(void) strcpy(image->filename,filename);
status=OpenBlob(image_info,image,WriteBinaryType);
if (status == False)
WriterExit(FileOpenWarning,"Unable to open file",image);
LSBFirstWriteLong(image,0xc6d3d0c5ul);
LSBFirstWriteLong(image,30);
LSBFirstWriteLong(image,eps_length);
LSBFirstWriteLong(image,0);
LSBFirstWriteLong(image,0);
LSBFirstWriteLong(image,eps_length+30);
LSBFirstWriteLong(image,tiff_length);
LSBFirstWriteShort(image,0xffff);
for (c=fgetc(ps_file); c != EOF; c=fgetc(ps_file))
(void) WriteByte(image,(char) c);
for (c=fgetc(tiff_file); c != EOF; c=fgetc(tiff_file))
(void) WriteByte(image,(char) c);
(void) fclose(tiff_file);
CloseBlob(image);
return(True);
}
static int
mksplit(const char *file_src, const char *prefix, off_t maxpartsize,
bool msdos)
{
int fd_src;
struct stat st;
char hash[MD5HASHLEN + 1];
char *package, *version, *arch;
int nparts, curpart;
off_t partsize;
off_t cur_partsize, last_partsize;
char *prefixdir = NULL, *msdos_prefix = NULL;
struct varbuf file_dst = VARBUF_INIT;
struct varbuf partmagic = VARBUF_INIT;
struct varbuf partname = VARBUF_INIT;
fd_src = open(file_src, O_RDONLY);
if (fd_src < 0)
ohshite(_("unable to open source file `%.250s'"), file_src);
if (fstat(fd_src, &st))
ohshite(_("unable to fstat source file"));
if (!S_ISREG(st.st_mode))
ohshit(_("source file `%.250s' not a plain file"), file_src);
fd_md5(fd_src, hash, -1, "md5hash");
lseek(fd_src, 0, SEEK_SET);
/* FIXME: Use libdpkg-deb. */
package = deb_field(file_src, "Package");
version = deb_field(file_src, "Version");
arch = deb_field(file_src, "Architecture");
partsize = maxpartsize - HEADERALLOWANCE;
last_partsize = st.st_size % partsize;
if (last_partsize == 0)
last_partsize = partsize;
nparts = (st.st_size + partsize - 1) / partsize;
setvbuf(stdout, NULL, _IONBF, 0);
printf(P_("Splitting package %s into %d part: ",
"Splitting package %s into %d parts: ", nparts),
package, nparts);
if (msdos) {
char *t;
t = m_strdup(prefix);
prefixdir = m_strdup(dirname(t));
free(t);
msdos_prefix = m_strdup(path_basename(prefix));
prefix = clean_msdos_filename(msdos_prefix);
}
for (curpart = 1; curpart <= nparts; curpart++) {
int fd_dst;
varbuf_reset(&file_dst);
/* Generate output filename. */
if (msdos) {
char *refname;
int prefix_max;
m_asprintf(&refname, "%dof%d", curpart, nparts);
prefix_max = max(8 - strlen(refname), 0);
varbuf_printf(&file_dst, "%s/%.*s%.8s.deb",
prefixdir, prefix_max, prefix, refname);
free(refname);
} else {
varbuf_printf(&file_dst, "%s.%dof%d.deb",
prefix, curpart, nparts);
}
if (curpart == nparts)
cur_partsize = last_partsize;
else
cur_partsize = partsize;
if (cur_partsize > maxpartsize) {
ohshit(_("Header is too long, making part too long. "
"Your package name or version\n"
"numbers must be extraordinarily long, "
"or something. Giving up.\n"));
}
/* Split the data. */
fd_dst = creat(file_dst.buf, 0644);
if (fd_dst < 0)
ohshite(_("unable to open file '%s'"), file_dst.buf);
/* Write the ar header. */
dpkg_ar_put_magic(file_dst.buf, fd_dst);
/* Write the debian-split part. */
varbuf_printf(&partmagic,
"%s\n%s\n%s\n%s\n%jd\n%jd\n%d/%d\n%s\n",
SPLITVERSION, package, version, hash,
(intmax_t)st.st_size, (intmax_t)partsize,
curpart, nparts, arch);
dpkg_ar_member_put_mem(file_dst.buf, fd_dst, PARTMAGIC,
partmagic.buf, partmagic.used);
varbuf_reset(&partmagic);
/* Write the data part. */
varbuf_printf(&partname, "data.%d", curpart);
dpkg_ar_member_put_file(file_dst.buf, fd_dst, partname.buf,
fd_src, cur_partsize);
varbuf_reset(&partname);
close(fd_dst);
printf("%d ", curpart);
}
varbuf_destroy(&file_dst);
varbuf_destroy(&partname);
varbuf_destroy(&partmagic);
free(prefixdir);
free(msdos_prefix);
close(fd_src);
printf(_("done\n"));
return 0;
}
