/* author/hw/title[/:track:loop:time] */
static char * convert_music_path(char * newname, int max,
const char *name,
rsc68_info_t * info)
{
int len, c;
char * nname = newname;
char * ename = nname+max;
/* Author */
len = copy_path(nname, ename - nname, name, 0, 0, '/');
if (len <= 0) goto error;
nname += len;
name += len;
/* Hardware */
c = (*name++) & 255;
if (c == '0') {
len = copy_path(nname, ename - nname, "Atari ST/", 0, 0, 0);
} else if (c == '1') {
len = copy_path(nname, ename - nname, "Amiga/", 0, 0, 0);
} else {
len = -1;
}
if (len <= 0) goto error;
nname += len;
c = (*name++) & 255;
if (c != '/') goto error;
/* Title */
len = copy_path(nname, ename - nname, name, 0, 0, '/');
if (len <= 0) goto error;
nname += len;
name += len;
if (nname[-1] == '/') {
--nname;
}
*nname = 0;
/* Optional track # */
name = rsc68_get_music_params(info, name);
return newname;
error:
*newname = 0;
return 0;
}
/* sysfile_rename - rename file */
int
sysfile_rename(const char *__path1, const char *__path2) {
int ret;
char *old_path, *new_path;
if ((ret = copy_path(&old_path, __path1)) != 0) {
return ret;
}
if ((ret = copy_path(&new_path, __path2)) != 0) {
kfree(old_path);
return ret;
}
ret = vfs_rename(old_path, new_path);
kfree(old_path), kfree(new_path);
return ret;
}
/*===========================================================================*
* do_chroot *
*===========================================================================*/
int do_chroot(void)
{
/* Perform the chroot(name) system call.
* syscall might provide 'name' embedded in the message.
*/
int r;
struct vnode *vp;
struct vmnt *vmp;
char fullpath[PATH_MAX];
struct lookup resolve;
if (!super_user) return(EPERM); /* only su may chroot() */
if (copy_path(fullpath, sizeof(fullpath)) != OK)
return(err_code);
/* Try to open the directory */
lookup_init(&resolve, fullpath, PATH_NOFLAGS, &vmp, &vp);
resolve.l_vmnt_lock = VMNT_READ;
resolve.l_vnode_lock = VNODE_READ;
if ((vp = eat_path(&resolve, fp)) == NULL) return(err_code);
r = change_into(&fp->fp_rd, vp);
unlock_vnode(vp);
unlock_vmnt(vmp);
put_vnode(vp);
return(r);
}
virtual int on_reached_special_file() override
{
if (_curr->fts_level == 0) {
return Action::FTS_OK;
}
return copy_path() ? Action::FTS_OK : Action::FTS_Fail;
}
/*===========================================================================*
* do_mkdir *
*===========================================================================*/
int do_mkdir(void)
{
/* Perform the mkdir(name, mode) system call. */
mode_t bits; /* mode bits for the new inode */
int r;
struct vnode *vp;
struct vmnt *vmp;
char fullpath[PATH_MAX];
struct lookup resolve;
mode_t dirmode;
if (copy_path(fullpath, sizeof(fullpath)) != OK)
return(err_code);
dirmode = job_m_in.m_lc_vfs_path.mode;
lookup_init(&resolve, fullpath, PATH_NOFLAGS, &vmp, &vp);
resolve.l_vmnt_lock = VMNT_WRITE;
resolve.l_vnode_lock = VNODE_WRITE;
bits = I_DIRECTORY | (dirmode & RWX_MODES & fp->fp_umask);
if ((vp = last_dir(&resolve, fp)) == NULL) return(err_code);
/* Make sure that the object is a directory */
if (!S_ISDIR(vp->v_mode)) {
r = ENOTDIR;
} else if ((r = forbidden(fp, vp, W_BIT|X_BIT)) == OK) {
r = req_mkdir(vp->v_fs_e, vp->v_inode_nr, fullpath, fp->fp_effuid,
fp->fp_effgid, bits);
}
unlock_vnode(vp);
unlock_vmnt(vmp);
put_vnode(vp);
return(r);
}
void snap_path_for_fill(std::shared_ptr< cairo_t>& cr) {
snap_path_closure_t spc{ 1,1, cr };
auto path = copy_path(cr);
for (int i = 0; i < path->num_data; i += path->data[i].header.length) {
cairo_path_data_t* data = &path->data[i];
switch (data->header.type) {
case CAIRO_PATH_MOVE_TO:
spc_move_to(spc, data[1].point.x, data[1].point.y);
break;
case CAIRO_PATH_LINE_TO:
spc_line_to(spc, data[1].point.x, data[1].point.y);
break;
case CAIRO_PATH_CURVE_TO:
spc_curve_to(spc, data[1].point.x, data[1].point.y,
data[2].point.x, data[2].point.y,
data[3].point.x, data[3].point.y);
break;
case CAIRO_PATH_CLOSE_PATH:
spc_close_path(spc);
break;
}
}
}
int afp_getextattr(struct afp_volume * volume, unsigned int dirid,
unsigned short bitmap, unsigned int replysize ,
char * pathname,
unsigned short namelen, char * name, struct afp_extattr_info * i)
{
struct {
struct dsi_header dsi_header __attribute__((__packed__));
uint8_t command;
char pad;
uint16_t volid ;
uint32_t dirid ;
uint16_t bitmap ;
uint64_t offset ;
uint64_t reqcount;
uint32_t replysize;
} __attribute__((__packed__)) *request_packet;
struct {
uint16_t len;
char * name ;
} __attribute__((__packed__)) * req2;
struct afp_server * server = volume->server;
unsigned int len = sizeof(*request_packet)+
sizeof_path_header(server)+strlen(pathname)
+1+sizeof(unsigned int) + strlen(name);
char * p,*p2;
int ret;
char * msg = malloc(len);
if (!msg) {
log_for_client(NULL,AFPFSD,LOG_WARNING,"Out of memory\n");
return -1;
};
p= msg + (sizeof(*request_packet));
request_packet=(void *) msg;
dsi_setup_header(server,&request_packet->dsi_header,DSI_DSICommand);
request_packet->command=afpGetExtAttr;
request_packet->pad=0;
request_packet->volid=htons(volume->volid);
request_packet->dirid=htonl(dirid);
request_packet->offset=hton64(0);
request_packet->reqcount=hton64(0);
request_packet->replysize=htonl(replysize);
copy_path(server,p,pathname,strlen(pathname));
unixpath_to_afppath(server,p);
p2=p+sizeof_path_header(server)+strlen(pathname);
if (((unsigned int ) p2) & 0x1) p2++;
req2=(void *) p2;
req2->len=htons(namelen);
memcpy(&req2->name,name,namelen);
len=(p2+namelen)-msg;
ret=dsi_send(server, (char *) request_packet,len,DSI_DEFAULT_TIMEOUT,
afpDelete ,(void *) i);
free(msg);
return ret;
}
int afp_enumerate(
struct afp_volume * volume,
unsigned int dirid,
unsigned int filebitmap, unsigned int dirbitmap,
unsigned short reqcount,
unsigned short startindex,
char * pathname,
struct afp_file_info ** file_p)
{
struct {
struct dsi_header dsi_header __attribute__((__packed__));
uint8_t command;
uint8_t pad;
uint16_t volid;
uint32_t dirid;
uint16_t filebitmap;
uint16_t dirbitmap;
uint16_t reqcount;
uint16_t startindex;
uint16_t maxreplysize;
} __attribute__((__packed__)) * afp_enumerate_request_packet;
unsigned short len;
char * data;
int rc;
struct afp_file_info * files = NULL;
struct afp_server * server = volume->server;
char * path;
len = sizeof_path_header(server) + strlen(pathname) +
sizeof(*afp_enumerate_request_packet);
if ((data=malloc(len))==NULL)
return -1;
path = data+sizeof(*afp_enumerate_request_packet);
afp_enumerate_request_packet = (void *) data;
dsi_setup_header(server,&afp_enumerate_request_packet->dsi_header,DSI_DSICommand);
afp_enumerate_request_packet->command=afpEnumerate;
afp_enumerate_request_packet->pad=0;
afp_enumerate_request_packet->volid=htons(volume->volid);
afp_enumerate_request_packet->dirid=htonl(dirid);
afp_enumerate_request_packet->filebitmap=htons(filebitmap);
afp_enumerate_request_packet->dirbitmap=htons(dirbitmap);
afp_enumerate_request_packet->reqcount=htons(reqcount);
afp_enumerate_request_packet->startindex=htons(startindex);
afp_enumerate_request_packet->maxreplysize=htons(5280);
copy_path(server,path,pathname,strlen(pathname));
unixpath_to_afppath(server,path);
rc=dsi_send(server, (char *) data,len,DSI_DEFAULT_TIMEOUT,
afpEnumerate,(void **) &files);
*file_p = files;
free(data);
return rc;
}
int afp_rename(struct afp_volume *volume,
unsigned int dirid,
char * path_from, char * path_to)
{
struct {
struct dsi_header dsi_header __attribute__((__packed__));
uint8_t command;
uint8_t pad;
uint16_t volid;
uint32_t dirid;
} __attribute__((__packed__)) * request_packet;
char * pathfromptr, *pathtoptr;
char * msg;
struct afp_server * server = volume->server;
unsigned int len = sizeof(*request_packet) +
sizeof_path_header(server) + strlen(path_from) +
sizeof_path_header(server) + strlen(path_to);
int ret;
if ((msg=malloc(len)) == NULL)
return -1;
request_packet=(void *) msg;
dsi_setup_header(server,&request_packet->dsi_header,DSI_DSICommand);
request_packet->command=afpRename;
request_packet->pad=0;
request_packet->volid=htons(volume->volid);
request_packet->dirid=htonl(dirid);
pathfromptr=msg+sizeof(*request_packet);
copy_path(server,pathfromptr,path_from,strlen(path_from));
unixpath_to_afppath(server,pathfromptr);
pathtoptr=pathfromptr+sizeof_path_header(server) + strlen(path_from);
copy_path(server,pathtoptr,path_to,strlen(path_to));
unixpath_to_afppath(server,pathtoptr);
ret=dsi_send(server, (char *) msg,len,DSI_DEFAULT_TIMEOUT,
afpRename,NULL);
free(msg);
return ret;
}
int sysfile_open(const char *__path, uint32_t open_flags)
{
int ret;
char *path;
if ((ret = copy_path(&path, __path)) != 0) {
return ret;
}
ret = file_open(path, open_flags);
kfree(path);
return ret;
}
/* sysfile_unlink - unlink file */
int
sysfile_unlink(const char *__path) {
int ret;
char *path;
if ((ret = copy_path(&path, __path)) != 0) {
return ret;
}
ret = vfs_unlink(path);
kfree(path);
return ret;
}
int
sysfile_mkfifo(const char *__name, uint32_t open_flags) {
int ret;
char *name;
if ((ret = copy_path(&name, __name)) != 0) {
return ret;
}
ret = file_mkfifo(name, open_flags);
kfree(name);
return ret;
}
/* Initializes the outer whole trim plus the three trimming paths
* required to trim the logo.
*/
void init_trims(void) {
int i;
/* whole outer path, counter clockwise, so NuRB is not trimmed */
whole = &ccl_path;
whole->pieces = 1;
whole->trim = ccl_square;
/* initial third of logo, centered at origin */
path[0] = &initial_path;
path[0]->pieces = ELEMENTS(initial_pieces);
path[0]->trim = initial_pieces;
for(i=0; i < path[0]->pieces - 1; i++)
join_trims(&path[0]->trim[i], &path[0]->trim[i+1], LOGO_RADIUS);
/* copy other to other two thirds */
copy_path(path[0],&path[1]);
copy_path(path[0],&path[2]);
/* scale and translate first third */
for (i=0; i<path[0]->pieces; i++) {
scale_trim(&path[0]->trim[i],0.5,1.0);
translate_trim(&path[0]->trim[i],0.5,0.52);
}
/* rotate, scale and translate second third */
for (i=0; i<path[1]->pieces; i++) {
rotate_trim(&path[1]->trim[i],2.0*M_PI/3.0);
scale_trim(&path[1]->trim[i],0.5,1.0);
translate_trim(&path[1]->trim[i],0.49,0.5);
}
/* rotate, scale and translate last third */
for (i=0; i<path[2]->pieces; i++) {
rotate_trim(&path[2]->trim[i],2.0*2.0*M_PI/3.0);
scale_trim(&path[2]->trim[i],0.5,1.0);
translate_trim(&path[2]->trim[i],0.51,0.5);
}
}
/*===========================================================================*
* do_open *
*===========================================================================*/
int do_open(void)
{
/* Perform the open(name, flags) system call with O_CREAT *not* set. */
int open_flags;
char fullpath[PATH_MAX];
open_flags = job_m_in.m_lc_vfs_path.flags;
if (open_flags & O_CREAT)
return EINVAL;
if (copy_path(fullpath, sizeof(fullpath)) != OK)
return(err_code);
return common_open(fullpath, open_flags, 0 /*omode*/, FALSE /*for_exec*/);
}
int afp_openfork(struct afp_volume * volume,
unsigned char forktype,
unsigned int dirid,
unsigned short accessmode,
char * filename,
struct afp_file_info * fp)
{
struct {
struct dsi_header dsi_header __attribute__((__packed__));
uint8_t command;
uint8_t forktype;
uint16_t volid;
uint32_t dirid ;
uint16_t bitmap ;
uint16_t accessmode;
} __attribute__((__packed__)) * afp_openfork_request;
char * msg;
char *pathptr;
struct afp_server * server = volume->server;
unsigned int len = sizeof(*afp_openfork_request) +
sizeof_path_header(server) + strlen(filename);
int ret;
if ((msg=malloc(len)) == NULL)
return -1;
pathptr=msg+sizeof(*afp_openfork_request);
afp_openfork_request = (void *) msg;
dsi_setup_header(server,&afp_openfork_request->dsi_header,DSI_DSICommand);
afp_openfork_request->command=afpOpenFork;
afp_openfork_request->forktype=forktype ? AFP_FORKTYPE_RESOURCE : AFP_FORKTYPE_DATA;
afp_openfork_request->bitmap=0;
afp_openfork_request->volid=htons(volume->volid);
afp_openfork_request->dirid=htonl(dirid);
afp_openfork_request->accessmode=htons(accessmode);
copy_path(server,pathptr,filename,strlen(filename));
unixpath_to_afppath(server,pathptr);
ret=dsi_send(server, (char *) msg,len,DSI_DEFAULT_TIMEOUT,
afpOpenFork,(void *) fp);
free(msg);
return ret;
}
int afp_listextattr(struct afp_volume * volume,
unsigned int dirid, unsigned short bitmap,
char * pathname, struct afp_extattr_info * info)
{
struct {
struct dsi_header dsi_header __attribute__((__packed__));
uint8_t command;
uint8_t pad;
uint16_t volid ;
uint32_t dirid ;
uint16_t bitmap;
uint16_t reqcount;
uint32_t startindex;
uint32_t maxreplysize;
} __attribute__((__packed__)) *request_packet;
struct afp_server * server=volume->server;
unsigned int len = sizeof(*request_packet)+sizeof_path_header(server)+strlen(pathname);
char * pathptr;
int ret;
char * msg = malloc(len);
if (!msg) {
log_for_client(NULL,AFPFSD,LOG_WARNING,"Out of memory\n");
return -1;
};
pathptr = msg + (sizeof(*request_packet));
request_packet=(void *) msg;
dsi_setup_header(server,&request_packet->dsi_header,DSI_DSICommand);
request_packet->command=afpListExtAttrs;
request_packet->pad=0;
request_packet->volid=htons(volume->volid);
request_packet->dirid=htonl(dirid);
request_packet->reqcount=0;
request_packet->startindex=0;
request_packet->bitmap=htons(bitmap);
request_packet->maxreplysize=hton64(info->maxsize);
copy_path(server,pathptr,pathname,strlen(pathname));
unixpath_to_afppath(server,pathptr);
ret=dsi_send(server, (char *) request_packet,len,DSI_DEFAULT_TIMEOUT,
afpListExtAttrs , (void *) info);
free(msg);
return ret;
}
void clip_rgn_mix(drawingStates *states, PATH *path, uint32_t mode) {
// FIXME need to handle clip region definition properly.
// Need to calculate new clipping form.
// it's not trivial, use a lib like polyclip (cpp) which in turn
// needs to convert Bezier/ARC curves in segment.
switch (mode) {
case U_RGN_NONE:
case U_RGN_AND:
case U_RGN_OR:
case U_RGN_XOR:
case U_RGN_DIFF:
case U_RGN_COPY:
default:
free_path(&(states->currentDeviceContext.clipRGN));
copy_path(path, &(states->currentDeviceContext.clipRGN));
break;
}
}
int afp_setextattr(struct afp_volume * volume, unsigned int dirid,
unsigned short bitmap, uint64_t offset, char * pathname,
unsigned short namelen, char * name, unsigned int attribdatalen,
char * attribdata)
{
struct {
struct dsi_header dsi_header __attribute__((__packed__));
uint8_t command;
uint8_t pad;
uint16_t volid ;
uint32_t dirid ;
uint16_t bitmap ;
uint64_t offset ;
} __attribute__((__packed__)) *request_packet;
struct afp_server * server = volume->server;
unsigned int len = sizeof(*request_packet)+sizeof_path_header(server)+strlen(pathname);
char * pathptr;
int ret;
char * msg = malloc(len);
if (!msg) {
log_for_client(NULL,AFPFSD,LOG_WARNING,"Out of memory\n");
return -1;
};
pathptr = msg + (sizeof(*request_packet));
request_packet=(void *) msg;
dsi_setup_header(server,&request_packet->dsi_header,DSI_DSICommand);
request_packet->command=afpSetExtAttr;
request_packet->pad=0;
request_packet->volid=htons(volume->volid);
request_packet->dirid=htonl(dirid);
copy_path(server,pathptr,pathname,strlen(pathname));
unixpath_to_afppath(server,pathptr);
ret=dsi_send(server, (char *) request_packet,len,DSI_DEFAULT_TIMEOUT,
afpDelete ,NULL);
free(msg);
return ret;
}
static status_t
normalize_path(const char* path, char* buffer, size_t bufferSize)
{
status_t error;
if (bufferSize >= B_PATH_NAME_LENGTH) {
error = _kern_normalize_path(path, true, buffer);
} else {
char normalizedPath[B_PATH_NAME_LENGTH];
error = _kern_normalize_path(path, true, normalizedPath);
if (error == B_OK)
error = copy_path(path, buffer, bufferSize);
}
if (error != B_OK)
return error;
// make sure the path exists
struct stat st;
if (lstat(buffer, &st) != 0)
return errno;
return B_OK;
}
static int
archive_write_zip_header(struct archive_write *a, struct archive_entry *entry)
{
unsigned char local_header[32];
unsigned char local_extra[128];
struct zip *zip = a->format_data;
unsigned char *e;
unsigned char *cd_extra;
size_t filename_length;
const char *slink = NULL;
size_t slink_size = 0;
struct archive_string_conv *sconv = get_sconv(a, zip);
int ret, ret2 = ARCHIVE_OK;
int64_t size;
mode_t type;
int version_needed = 10;
/* Ignore types of entries that we don't support. */
type = archive_entry_filetype(entry);
if (type != AE_IFREG && type != AE_IFDIR && type != AE_IFLNK) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Filetype not supported");
return ARCHIVE_FAILED;
};
/* If we're not using Zip64, reject large files. */
if (zip->flags & ZIP_FLAG_AVOID_ZIP64) {
/* Reject entries over 4GB. */
if (archive_entry_size_is_set(entry)
&& (archive_entry_size(entry) > 0xffffffff)) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Files > 4GB require Zip64 extensions");
return ARCHIVE_FAILED;
}
/* Reject entries if archive is > 4GB. */
if (zip->written_bytes > 0xffffffff) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Archives > 4GB require Zip64 extensions");
return ARCHIVE_FAILED;
}
}
/* Only regular files can have size > 0. */
if (type != AE_IFREG)
archive_entry_set_size(entry, 0);
/* Reset information from last entry. */
zip->entry_offset = zip->written_bytes;
zip->entry_uncompressed_limit = INT64_MAX;
zip->entry_compressed_size = 0;
zip->entry_uncompressed_size = 0;
zip->entry_compressed_written = 0;
zip->entry_uncompressed_written = 0;
zip->entry_flags = 0;
zip->entry_uses_zip64 = 0;
zip->entry_crc32 = zip->crc32func(0, NULL, 0);
if (zip->entry != NULL) {
archive_entry_free(zip->entry);
zip->entry = NULL;
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* Make sure the path separators in pahtname, hardlink and symlink
* are all slash '/', not the Windows path separator '\'. */
zip->entry = __la_win_entry_in_posix_pathseparator(entry);
if (zip->entry == entry)
zip->entry = archive_entry_clone(entry);
#else
zip->entry = archive_entry_clone(entry);
#endif
if (zip->entry == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate zip header data");
return (ARCHIVE_FATAL);
}
if (sconv != NULL) {
const char *p;
size_t len;
if (archive_entry_pathname_l(entry, &p, &len, sconv) != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for Pathname");
return (ARCHIVE_FATAL);
}
archive_set_error(&a->archive,
ARCHIVE_ERRNO_FILE_FORMAT,
"Can't translate Pathname '%s' to %s",
archive_entry_pathname(entry),
archive_string_conversion_charset_name(sconv));
ret2 = ARCHIVE_WARN;
}
if (len > 0)
archive_entry_set_pathname(zip->entry, p);
/*
* There is no standard for symlink handling; we convert
* it using the same character-set translation that we use
* for filename.
*/
if (type == AE_IFLNK) {
if (archive_entry_symlink_l(entry, &p, &len, sconv)) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory "
" for Symlink");
return (ARCHIVE_FATAL);
}
/* No error if we can't convert. */
} else if (len > 0)
archive_entry_set_symlink(zip->entry, p);
}
}
/* If filename isn't ASCII and we can use UTF-8, set the UTF-8 flag. */
if (!is_all_ascii(archive_entry_pathname(zip->entry))) {
if (zip->opt_sconv != NULL) {
if (strcmp(archive_string_conversion_charset_name(
zip->opt_sconv), "UTF-8") == 0)
zip->entry_flags |= ZIP_ENTRY_FLAG_UTF8_NAME;
#if HAVE_NL_LANGINFO
} else if (strcmp(nl_langinfo(CODESET), "UTF-8") == 0) {
zip->entry_flags |= ZIP_ENTRY_FLAG_UTF8_NAME;
#endif
}
}
filename_length = path_length(zip->entry);
/* Determine appropriate compression and size for this entry. */
if (type == AE_IFLNK) {
slink = archive_entry_symlink(zip->entry);
if (slink != NULL)
slink_size = strlen(slink);
else
slink_size = 0;
zip->entry_uncompressed_limit = slink_size;
zip->entry_compressed_size = slink_size;
zip->entry_uncompressed_size = slink_size;
zip->entry_crc32 = zip->crc32func(zip->entry_crc32,
(const unsigned char *)slink, slink_size);
zip->entry_compression = COMPRESSION_STORE;
version_needed = 20;
} else if (type != AE_IFREG) {
zip->entry_compression = COMPRESSION_STORE;
zip->entry_uncompressed_limit = 0;
size = 0;
version_needed = 20;
} else if (archive_entry_size_is_set(zip->entry)) {
size = archive_entry_size(zip->entry);
zip->entry_uncompressed_limit = size;
zip->entry_compression = zip->requested_compression;
if (zip->entry_compression == COMPRESSION_UNSPECIFIED) {
zip->entry_compression = COMPRESSION_DEFAULT;
}
if (zip->entry_compression == COMPRESSION_STORE) {
zip->entry_compressed_size = size;
zip->entry_uncompressed_size = size;
version_needed = 10;
} else {
zip->entry_uncompressed_size = size;
version_needed = 20;
}
if ((zip->flags & ZIP_FLAG_FORCE_ZIP64) /* User asked. */
|| (zip->entry_uncompressed_size > ARCHIVE_LITERAL_LL(0xffffffff))) { /* Large entry. */
zip->entry_uses_zip64 = 1;
version_needed = 45;
}
/* We may know the size, but never the CRC. */
zip->entry_flags |= ZIP_ENTRY_FLAG_LENGTH_AT_END;
} else {
/* Prefer deflate if it's available, because deflate
* has a clear end-of-data marker that makes
* length-at-end more reliable. */
zip->entry_compression = COMPRESSION_DEFAULT;
zip->entry_flags |= ZIP_ENTRY_FLAG_LENGTH_AT_END;
if ((zip->flags & ZIP_FLAG_AVOID_ZIP64) == 0) {
zip->entry_uses_zip64 = 1;
version_needed = 45;
} else if (zip->entry_compression == COMPRESSION_STORE) {
version_needed = 10;
} else {
version_needed = 20;
}
}
/* Format the local header. */
memset(local_header, 0, sizeof(local_header));
memcpy(local_header, "PK\003\004", 4);
archive_le16enc(local_header + 4, version_needed);
archive_le16enc(local_header + 6, zip->entry_flags);
archive_le16enc(local_header + 8, zip->entry_compression);
archive_le32enc(local_header + 10, dos_time(archive_entry_mtime(zip->entry)));
archive_le32enc(local_header + 14, zip->entry_crc32);
if (zip->entry_uses_zip64) {
/* Zip64 data in the local header "must" include both
* compressed and uncompressed sizes AND those fields
* are included only if these are 0xffffffff;
* THEREFORE these must be set this way, even if we
* know one of them is smaller. */
archive_le32enc(local_header + 18, ARCHIVE_LITERAL_LL(0xffffffff));
archive_le32enc(local_header + 22, ARCHIVE_LITERAL_LL(0xffffffff));
} else {
archive_le32enc(local_header + 18, zip->entry_compressed_size);
archive_le32enc(local_header + 22, zip->entry_uncompressed_size);
}
archive_le16enc(local_header + 26, filename_length);
/* Format as much of central directory file header as we can: */
zip->file_header = cd_alloc(zip, 46);
/* If (zip->file_header == NULL) XXXX */
++zip->central_directory_entries;
memset(zip->file_header, 0, 46);
memcpy(zip->file_header, "PK\001\002", 4);
/* "Made by PKZip 2.0 on Unix." */
archive_le16enc(zip->file_header + 4, 3 * 256 + version_needed);
archive_le16enc(zip->file_header + 6, version_needed);
archive_le16enc(zip->file_header + 8, zip->entry_flags);
archive_le16enc(zip->file_header + 10, zip->entry_compression);
archive_le32enc(zip->file_header + 12, dos_time(archive_entry_mtime(zip->entry)));
archive_le16enc(zip->file_header + 28, filename_length);
/* Following Info-Zip, store mode in the "external attributes" field. */
archive_le32enc(zip->file_header + 38,
((uint32_t)archive_entry_mode(zip->entry)) << 16);
e = cd_alloc(zip, filename_length);
/* If (e == NULL) XXXX */
copy_path(zip->entry, e);
/* Format extra data. */
memset(local_extra, 0, sizeof(local_extra));
e = local_extra;
/* First, extra blocks that are the same between
* the local file header and the central directory.
* We format them once and then duplicate them. */
/* UT timestamp, length depends on what timestamps are set. */
memcpy(e, "UT", 2);
archive_le16enc(e + 2,
1
+ (archive_entry_mtime_is_set(entry) ? 4 : 0)
+ (archive_entry_atime_is_set(entry) ? 4 : 0)
+ (archive_entry_ctime_is_set(entry) ? 4 : 0));
e += 4;
*e++ =
(archive_entry_mtime_is_set(entry) ? 1 : 0)
| (archive_entry_atime_is_set(entry) ? 2 : 0)
| (archive_entry_ctime_is_set(entry) ? 4 : 0);
if (archive_entry_mtime_is_set(entry)) {
archive_le32enc(e, (uint32_t)archive_entry_mtime(entry));
e += 4;
}
if (archive_entry_atime_is_set(entry)) {
archive_le32enc(e, (uint32_t)archive_entry_atime(entry));
e += 4;
}
if (archive_entry_ctime_is_set(entry)) {
archive_le32enc(e, (uint32_t)archive_entry_ctime(entry));
e += 4;
}
/* ux Unix extra data, length 11, version 1 */
/* TODO: If uid < 64k, use 2 bytes, ditto for gid. */
memcpy(e, "ux\013\000\001", 5);
e += 5;
*e++ = 4; /* Length of following UID */
archive_le32enc(e, (uint32_t)archive_entry_uid(entry));
e += 4;
*e++ = 4; /* Length of following GID */
archive_le32enc(e, (uint32_t)archive_entry_gid(entry));
e += 4;
/* Copy UT and ux into central directory as well. */
zip->file_header_extra_offset = zip->central_directory_bytes;
cd_extra = cd_alloc(zip, e - local_extra);
memcpy(cd_extra, local_extra, e - local_extra);
/*
* Following extra blocks vary between local header and
* central directory. These are the local header versions.
* Central directory versions get formatted in
* archive_write_zip_finish_entry() below.
*/
/* "[Zip64 entry] in the local header MUST include BOTH
* original [uncompressed] and compressed size fields." */
if (zip->entry_uses_zip64) {
unsigned char *zip64_start = e;
memcpy(e, "\001\000\020\000", 4);
e += 4;
archive_le64enc(e, zip->entry_uncompressed_size);
e += 8;
archive_le64enc(e, zip->entry_compressed_size);
e += 8;
archive_le16enc(zip64_start + 2, e - (zip64_start + 4));
}
if (zip->flags & ZIP_FLAG_EXPERIMENT_EL) {
/* Experimental 'el' extension to improve streaming. */
unsigned char *external_info = e;
int included = 7;
memcpy(e, "el\000\000", 4); // 0x6c65 + 2-byte length
e += 4;
e[0] = included; /* bitmap of included fields */
e += 1;
if (included & 1) {
archive_le16enc(e, /* "Version created by" */
3 * 256 + version_needed);
e += 2;
}
if (included & 2) {
archive_le16enc(e, 0); /* internal file attributes */
e += 2;
}
if (included & 4) {
archive_le32enc(e, /* external file attributes */
((uint32_t)archive_entry_mode(zip->entry)) << 16);
e += 4;
}
if (included & 8) {
// Libarchive does not currently support file comments.
}
archive_le16enc(external_info + 2, e - (external_info + 4));
}
/* Update local header with size of extra data and write it all out: */
archive_le16enc(local_header + 28, e - local_extra);
ret = __archive_write_output(a, local_header, 30);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += 30;
ret = write_path(zip->entry, a);
if (ret <= ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += ret;
ret = __archive_write_output(a, local_extra, e - local_extra);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += e - local_extra;
/* For symlinks, write the body now. */
if (slink != NULL) {
ret = __archive_write_output(a, slink, slink_size);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->entry_compressed_written += slink_size;
zip->entry_uncompressed_written += slink_size;
zip->written_bytes += slink_size;
}
#ifdef HAVE_ZLIB_H
if (zip->entry_compression == COMPRESSION_DEFLATE) {
zip->stream.zalloc = Z_NULL;
zip->stream.zfree = Z_NULL;
zip->stream.opaque = Z_NULL;
zip->stream.next_out = zip->buf;
zip->stream.avail_out = (uInt)zip->len_buf;
if (deflateInit2(&zip->stream, Z_DEFAULT_COMPRESSION,
Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
archive_set_error(&a->archive, ENOMEM,
"Can't init deflate compressor");
return (ARCHIVE_FATAL);
}
}
#endif
return (ret2);
}
int bcp_implementation::run()
{
//
// check output path is OK:
//
if(!m_list_mode && !m_license_mode && !fs::exists(m_dest_path))
{
std::string msg("Destination path does not exist: ");
msg.append(m_dest_path.native_file_string());
std::runtime_error e(msg);
boost::throw_exception(e);
}
// start by building a list of permitted files
// if m_cvs_mode is true:
if(m_cvs_mode)
{
scan_cvs_path(fs::path());
}
//
// if in license mode, try to load more/blanket_permission.txt
//
fs::path blanket_permission(m_boost_path / "more" / "blanket-permission.txt");
if (fs::exists(blanket_permission)) {
fs::ifstream in(blanket_permission);
std::string line;
while (std::getline(in, line)) {
boost::regex e("([^(]+)\\(");
boost::smatch result;
if (boost::regex_search(line, result, e))
m_bsl_authors.insert(format_authors_name(result[1]));
}
}
//
// scan through modules looking for the equivalent
// file to add to our list:
//
std::list<std::string>::const_iterator i = m_module_list.begin();
std::list<std::string>::const_iterator j = m_module_list.end();
while(i != j)
{
//
// convert *i to a path - could be native or portable:
//
fs::path module;
fs::path exmodule;
try{
module = fs::path(*i);
exmodule = fs::path(*i + ".hpp");
}
catch(...)
{
module = fs::path(*i, fs::native);
exmodule = fs::path(*i + ".hpp", fs::native);
}
if(m_scan_mode)
{
// in scan mode each module must be a real file:
add_file_dependencies(module, true);
}
else
{
int count = 0;
if(fs::exists(m_boost_path / "tools" / module))
{
add_path(fs::path("tools") / module);
++count;
}
if(fs::exists(m_boost_path / "libs" / module))
{
add_path(fs::path("libs") / module);
++count;
}
if(fs::exists(m_boost_path / "boost" / module))
{
add_path(fs::path("boost") / module);
++count;
}
if(fs::exists(m_boost_path / "boost" / exmodule))
{
add_path(fs::path("boost") / exmodule);
++count;
}
if(fs::exists(m_boost_path / module))
{
add_path(module);
++count;
}
}
++i;
}
//
// now perform output:
//
std::set<fs::path, path_less>::iterator m, n;
std::set<fs::path, path_less> short_paths;
m = m_copy_paths.begin();
n = m_copy_paths.end();
if(!m_license_mode)
{
while(m != n)
{
if(m_list_summary_mode)
{
fs::path p = get_short_path(*m);
if(short_paths.find(p) == short_paths.end())
{
short_paths.insert(p);
std::cout << p.string() << "\n";
}
}
else if(m_list_mode)
std::cout << m->string() << "\n";
else
copy_path(*m);
++m;
}
}
else
output_license_info();
return 0;
}
int afp_moveandrename(struct afp_volume *volume,
unsigned int src_did,
unsigned int dst_did,
char * src_path, char * dst_path, char *new_name)
{
struct {
struct dsi_header dsi_header __attribute__((__packed__));
uint8_t command;
uint8_t pad;
uint16_t volid ;
uint32_t src_did;
uint32_t dst_did ;
} __attribute__((__packed__)) * request_packet;
char * p;
char * msg;
struct afp_server * server = volume->server;
unsigned int len;
unsigned int dlen=0,slen=0,nlen=0;
int ret;
unsigned short header_len=sizeof_path_header(server);
char null_path[255];
if (dst_path==NULL) {
null_path[0]='\0';
dlen=0;
dst_path=null_path;
} else {
dlen=strlen(dst_path);
}
if (src_path) slen=strlen(src_path);
if (new_name) nlen=strlen(new_name);
len = sizeof(*request_packet) +
(3* header_len) +
dlen + slen + nlen;
if ((msg=malloc(len)) == NULL)
return -1;
request_packet=(void *) msg;
dsi_setup_header(server,&request_packet->dsi_header,DSI_DSICommand);
request_packet->command=afpMoveAndRename;
request_packet->pad=0;
request_packet->volid=htons(volume->volid);
request_packet->src_did=htonl(src_did);
request_packet->dst_did=htonl(dst_did);
p=msg+sizeof(*request_packet);
copy_path(server,p,src_path,slen);
unixpath_to_afppath(server,p);
p+=sizeof_path_header(server)+slen;
copy_path(server,p,dst_path,dlen);
unixpath_to_afppath(server,p);
p+=sizeof_path_header(server)+dlen;
copy_path(server,p,new_name,nlen);
unixpath_to_afppath(server,p);
ret=dsi_send(server, (char *) msg,len,DSI_DEFAULT_TIMEOUT,afpMoveAndRename,NULL);
free(msg);
return ret;
}
static vfs68_t * default_open(rsc68_t type, const char *name,
int mode, rsc68_info_t * info)
{
vfs68_t * is = 0;
int err = -1;
const char *subdir = 0, *ext = 0;
char tmp[1024], * apath = 0;
char tmpname[512];
int alen = 0;
char_cv_t cv_path=0, cv_extra=0;
struct {
const char * path, * sdir, * ext;
int curl;
} pathes[4];
int ipath, npath = 0;
const char * share_path = default_share_path();
const char * rmusic_path = default_rmusic_path();
/* default to invalid type. */
if (info) {
info->type = rsc68_last;
}
if ( (int) type < 0 || (int)type >= rsc68_last) {
return 0;
}
memset(pathes,0,sizeof(pathes));
if (type == rsc68_music && lmusic_path) {
/* local music path is prior to user share */
pathes[npath].path = lmusic_path;
pathes[npath].sdir = "/";
++npath;
}
/* Build default pathes list */
if (user_path) {
pathes[npath++].path = user_path;
}
switch (mode &= 3) {
case 1: case 2:
break;
default:
assert(!"invalid mode");
return 0;
}
if (mode == 1 && share_path) {
pathes[npath++].path = share_path;
}
subdir = rsc68_table[type].path;
ext = rsc68_table[type].ext;
/* Set a default name for config file if none is given. */
if (type == rsc68_config && (!name || !name[0])) {
name = "sc68";
}
TRACE68(rsc68_cat,"rsc68: open %c 'sc68://%s/%s%s'\n",
(mode==1)?'R':'W',rsc68_table[type].name, name, ext?ext:"");
/* Any specific stuff. */
switch (type) {
case rsc68_replay:
#if defined (USE_REPLAY68) && 0
/* Method using vfs to inflate data. Notice that unfortunatly
* we can't use a proper Z stream because the replay loader needs
* to know the length and vfs68_z::length() method does not
* have this information before it has inflated the all data. This
* is a limitation that could probably be dealt with, at least
* with gziped stream as the information is available at the end
* of the stream. Also in this particular case the inflate size is
* available via the replay68_get() function.
*/
if (mode == 1) {
const void * cdata;
int csize, dsize;
vfs68_t * is_in;
TRACE68(rsc68_cat,"rsc68: trying built-in replay -- %s\n", name);
if (!replay68_get(name, &cdata, &csize, &dsize)) {
TRACE68(rsc68_cat,"rsc68: found built-in replay -- %s %d %d\n",
name, csize, dsize);
is_in =
vfs68_z_create(
vfs68_mem_create(cdata, csize, mode),
mode|VFS68_SLAVE,
vfs68_z_default_option);
if (is_in) {
is = vfs68_mem_create(0, dsize, 3);
if (!vfs68_open(is_in) && !vfs68_open(is)) {
int n;
while (n = vfs68_read(is_in, tmpname, sizeof(tmpname)), n > 0)
if (vfs68_write(is, tmpname, n) != n) {
n = -1;
break;
}
err = -!!n;
}
vfs68_destroy(is_in);
vfs68_seek_to(is,0);
}
}
}
#elif defined (USE_REPLAY68)
/* Method using gzip68_buffer() is probably faster (less memory
* copy) than the previous Z stream one. It still need to allocate
* a temporary buffer to store deflated data whereas a proper
* vfs could have deflated on the fly into the 68k memory
* buffer. See previous method comment on that matter.
*/
if (mode == 1) {
const void * cdata;
void * ddata;
int csize, dsize;
TRACE68(rsc68_cat,"rsc68: trying built-in replay -- %s\n", name);
if (!replay68_get(name, &cdata, &csize, &dsize)) {
TRACE68(rsc68_cat,"rsc68: found built-in replay -- %s %d %d\n",
name, csize, dsize);
ddata = malloc(dsize);
if (ddata) {
int inflate = gzip68_buffer(ddata, dsize, cdata, csize);
if (inflate != dsize) {
msg68_error("rsc68: inflated size of built-in replay differs"
" -- %s %d %d\n",name, inflate, dsize);
err = -1;
} else {
is = vfs68_mem_create(ddata, dsize, mode|VFS68_SLAVE);
if ( (err = -!is) != 0) {
free(ddata);
}
}
}
}
}
#endif
cv_extra = cv_lower; /* $$$ transform replay name to lower case. */
break;
case rsc68_music:
if (mode == 1 && rmusic_path) {
pathes[npath].path = rmusic_path;
pathes[npath].sdir = "/";
pathes[npath].curl = 1;
++npath;
}
name = convert_music_path(tmpname, sizeof(tmpname), name, info);
break;
default:
break;
}
for (ipath=0; !is && name && ipath < npath; ++ipath) {
const char *cpath, * cdir, * cext;
char *p, *pe, *path;
int len, l;
cpath = pathes[ipath].path;
cdir = pathes[ipath].sdir ? pathes[ipath].sdir : subdir;
cext = pathes[ipath].ext ? pathes[ipath].ext : ext;
len = 1
+ strlen(cpath)
+ strlen(cdir)
+ strlen(name)
+ (cext ? strlen(cext) : 0);
if (len <= alen) {
path = apath;
} else if (len <= sizeof(tmp)) {
path = tmp;
} else {
free(apath);
apath = malloc(len);
alen = apath ? len : 0;
path = apath;
}
if (!path) {
continue;
}
p = path;
pe = path + len;
cv_path = pathes[ipath].curl
? cv_path_remote
: cv_path_local;
/* Build path. */
l = copy_path(p, pe-p, cpath, cv_path, 0 , 0);
p += l;
l = copy_path(p, pe-p, cdir, cv_path, 0, 0);
p += l;
l = copy_path(p, pe-p, name, cv_path, cv_extra, 0);
p += l;
if (cext) {
l = copy_path(p, pe-p, cext, 0, 0 ,0);
p += l;
}
is = uri68_vfs(path, mode, 0);
err = vfs68_open(is);
TRACE68(rsc68_cat, "rsc68: try [%s]\n", strok68(err));
if (!err)
break;
vfs68_destroy(is);
is = 0;
}
if (apath != tmp)
free(apath);
if (err) {
vfs68_destroy(is);
is = 0;
}
if (is && info)
info->type = type;
TRACE68(rsc68_cat, "rsc68: open '%s' -- *%s*\n",
vfs68_filename(is),
strok68(!is));
return is;
}
void DoMediaCheck(const char *Dir)
{
carbon_debug("DoMediaCheck()\n");
char path[PATH_MAX], root[PATH_MAX];
install_info *install;
//if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radio)) ) {
// If path was specified
if(Dir)
{
/* We ignore the CDROM prefix in that case */
snprintf(path, sizeof(path), "%s/setup.data/setup.xml", Dir);
if ( access( path, R_OK) ) {
/* Doesn't look like a setup archive */
carbon_SetLabelText(Res, CHECK_STATUS_LABEL_ID, _("Unable to identify an installation media."));
return;
}
strncpy(root, Dir, sizeof(root));
}
// Else, assume they selected CDROM drive
else
{
/* Go through all CDROM devices and look for setup.xml files */
char *cds[SETUP_MAX_DRIVES];
int nb_drives = detect_and_mount_cdrom(cds), i;
for(i = 0; i < nb_drives; ++i ) {
snprintf(path, sizeof(path), "%s/%s/setup.data/setup.xml", cds[i], info->prefix);
if ( !access( path, R_OK) ) {
snprintf(root, sizeof(root), "%s/%s", cds[i], info->prefix);
break; /* FIXME: What if there are many setup CDs ? */
}
}
free_mounted_cdrom(nb_drives, cds);
}
/* Verify that the package is the same (product name and version) */
if(!check_xml_setup(path, info->name))
{
carbon_SetLabelText(Res, CHECK_STATUS_LABEL_ID, _("Installation media doesn't match the product."));
return;
}
carbon_SetLabelText(Res, CHECK_STATUS_LABEL_ID, _("Restoring files..."));
/* Fetch the files to be refreshed, i.e install with a restricted set of files */
install = create_install(path, info->root, NULL, info->prefix);
if ( install ) {
const char *f;
if ( chdir(root) < 0 ) {
fprintf(stderr, _("Unable to change to directory %s\n"), root);
} else {
/* Update the setup path */
strncpy(install->setup_path, root, sizeof(install->setup_path));
}
/* Check if we need to create a default component entry */
if ( GetProductNumComponents(install) == 0 ) {
current_component = add_component_entry(install, "Default", install->version, 1, NULL, NULL);
}
/* Restore any environment */
loki_put_envvars_component(loki_find_component(product, current_component->name));
/* Enable the relevant options */
select_corrupt_options(install);
copy_tree(install, install->config->root->childs, install->install_path, NULL);
/* Menu items are currently not being restored - maybe they should be tagged in setupdb ? */
/* Install the optional README and EULA files
Warning: those are always installed in the root of the installation directory!
*/
f = GetProductREADME(install);
if ( f && ! GetProductIsMeta(install) ) {
copy_path(install, f, install->install_path, NULL, 1, NULL, NULL);
}
f = GetProductEULA(install);
if ( f && ! GetProductIsMeta(install) ) {
copy_path(install, f, install->install_path, NULL, 1, NULL, NULL);
}
}
/* Print end message and disable the "Rescue" button */
carbon_SetLabelText(Res, CHECK_STATUS_LABEL_ID, _("Files successfully restored !"));
carbon_DisableControl(Res, CHECK_RESCUE_BUTTON_ID);
carbon_Prompt(Res, PromptType_OK, _("Files successfully restored !"), NULL, 0);
/* Unmount filesystems that may have been mounted */
unmount_filesystems();
}
status_t
internal_path_for_path(char* referencePath, size_t referencePathSize,
const char* dependency, const char* architecture,
path_base_directory baseDirectory, const char* subPath, uint32 flags,
char* pathBuffer, size_t bufferSize)
{
if (strcmp(architecture, __get_primary_architecture()) == 0)
architecture = NULL;
// resolve dependency
char packageName[B_FILE_NAME_LENGTH];
// Temporarily used here, permanently used below where
// B_FIND_PATH_PACKAGE_PATH is handled.
if (dependency != NULL) {
// get the versioned package name
status_t error = get_file_attribute(referencePath, "SYS:PACKAGE",
packageName, sizeof(packageName));
if (error != B_OK)
return error;
// normalize the dependency name
char normalizedDependency[B_FILE_NAME_LENGTH];
error = normalize_dependency(dependency, normalizedDependency,
sizeof(normalizedDependency));
if (error != B_OK)
return error;
// Compute the path of the dependency symlink. This will yield the
// installation location path when normalized.
if (snprintf(referencePath, referencePathSize,
kSystemPackageLinksDirectory "/%s/%s", packageName,
normalizedDependency)
>= (ssize_t)referencePathSize) {
return B_BUFFER_OVERFLOW;
}
}
// handle B_FIND_PATH_IMAGE_PATH
if (baseDirectory == B_FIND_PATH_IMAGE_PATH)
return copy_path(referencePath, pathBuffer, bufferSize);
// Handle B_FIND_PATH_PACKAGE_PATH: get the package file name and
// simply adjust our arguments to look the package file up in the packages
// directory.
if (baseDirectory == B_FIND_PATH_PACKAGE_PATH) {
status_t error = get_file_attribute(referencePath, "SYS:PACKAGE_FILE",
packageName, sizeof(packageName));
if (error != B_OK)
return error;
dependency = NULL;
subPath = packageName;
baseDirectory = B_FIND_PATH_PACKAGES_DIRECTORY;
flags = B_FIND_PATH_EXISTING_ONLY;
}
// normalize
status_t error = normalize_path(referencePath, referencePath,
referencePathSize);
if (error != B_OK)
return error;
// get the installation location
InstallationLocations* installationLocations = InstallationLocations::Get();
MethodDeleter<InstallationLocations> installationLocationsDeleter(
installationLocations, &InstallationLocations::Put);
size_t installationLocationIndex;
const char* installationLocation = installationLocations->LocationFor(
referencePath, installationLocationIndex);
if (installationLocation == NULL)
return B_ENTRY_NOT_FOUND;
// get base dir and process the path
const char* relativePath = get_relative_directory_path(
installationLocationIndex, baseDirectory);
if (relativePath == NULL)
return B_BAD_VALUE;
ssize_t pathSize = process_path(installationLocation, architecture,
relativePath, subPath, flags, pathBuffer, bufferSize);
if (pathSize <= 0)
return pathSize == 0 ? B_ENTRY_NOT_FOUND : pathSize;
return B_OK;
}
virtual int on_reached_special_file() override
{
return copy_path() ? Action::FTS_OK : Action::FTS_Fail;
}
virtual int on_reached_symlink() override
{
return copy_path() ? Action::FTS_OK : Action::FTS_Fail;
}
int bcp_implementation::run()
{
//
// check output path is OK:
//
if(!m_list_mode && !m_license_mode && !fs::exists(m_dest_path))
{
std::string msg("Destination path does not exist: ");
msg.append(m_dest_path.string());
std::runtime_error e(msg);
boost::throw_exception(e);
}
//
// Check Boost path is OK if it hasn't been checked already:
//
if(m_boost_path == "")
{
set_boost_path("");
}
// start by building a list of permitted files
// if m_cvs_mode is true:
if(m_cvs_mode)
{
std::cerr << "CAUTION: Boost is no longer in CVS, cvs mode may not work anymore!!!" << std::endl;
scan_cvs_path(fs::path());
}
if(m_svn_mode)
{
scan_svn_path(fs::path());
}
//
// if in license mode, try to load more/blanket_permission.txt
//
fs::path blanket_permission(m_boost_path / "more" / "blanket-permission.txt");
if (fs::exists(blanket_permission)) {
fs::ifstream in(blanket_permission);
std::string line;
while (std::getline(in, line)) {
static const boost::regex e("([^(]+)\\(");
boost::smatch result;
if (boost::regex_search(line, result, e))
m_bsl_authors.insert(format_authors_name(result[1]));
}
}
//
// scan through modules looking for the equivalent
// file to add to our list:
//
std::list<std::string>::const_iterator i = m_module_list.begin();
std::list<std::string>::const_iterator j = m_module_list.end();
while(i != j)
{
//
// convert *i to a path - could be native or portable:
//
fs::path module;
fs::path exmodule;
module = fs::path(*i);
exmodule = fs::path(*i + ".hpp");
if(m_scan_mode)
{
// in scan mode each module must be a real file:
add_file_dependencies(module, true);
}
else
{
int count = 0;
if(fs::exists(m_boost_path / "tools" / module))
{
add_path(fs::path("tools") / module);
++count;
}
if(fs::exists(m_boost_path / "libs" / module))
{
add_path(fs::path("libs") / module);
++count;
}
if(fs::exists(m_boost_path / "boost" / module))
{
add_path(fs::path("boost") / module);
++count;
}
if(fs::exists(m_boost_path / "boost" / exmodule))
{
add_path(fs::path("boost") / exmodule);
++count;
}
if(fs::exists(m_boost_path / module))
{
add_path(module);
++count;
}
}
++i;
}
//
// now perform output:
//
if(m_list_namespaces)
{
// List the namespaces, in two lists, headers and source files
// first, then everything else afterwards:
//
boost::regex important_file("boost/.*|libs/[^/]*/(?:[^/]*/)?/src/.*");
std::map<std::string, fs::path>::const_iterator i, j;
i = m_top_namespaces.begin();
j = m_top_namespaces.end();
std::cout << "\n\nThe top level namespaces found for header and source files were:\n";
while(i != j)
{
if(regex_match(i->second.string(), important_file))
std::cout << i->first << " (from " << i->second << ")" << std::endl;
++i;
}
i = m_top_namespaces.begin();
std::cout << "\n\nThe top level namespaces found for all other source files were:\n";
while(i != j)
{
if(!regex_match(i->second.string(), important_file))
std::cout << i->first << " (from " << i->second << ")" << std::endl;
++i;
}
return 0;
}
std::set<fs::path, path_less>::iterator m, n;
std::set<fs::path, path_less> short_paths;
m = m_copy_paths.begin();
n = m_copy_paths.end();
if(!m_license_mode)
{
while(m != n)
{
if(m_list_summary_mode)
{
fs::path p = get_short_path(*m);
if(short_paths.find(p) == short_paths.end())
{
short_paths.insert(p);
std::cout << p.string() << "\n";
}
}
else if(m_list_mode)
std::cout << m->string() << "\n";
else
copy_path(*m);
++m;
}
}
else
output_license_info();
return 0;
}
void
on_media_ok_clicked (GtkButton *button,
gpointer user_data)
{
GtkWidget *diag = glade_xml_get_widget(check_glade, "diagnostic_label"), *radio;
char path[PATH_MAX], root[PATH_MAX];
install_info *install;
radio = glade_xml_get_widget(rescue_glade, "dir_radio");
if ( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radio)) ) {
/* Directory */
const gchar *str = gtk_entry_get_text(GTK_ENTRY(glade_xml_get_widget(rescue_glade, "dir_entry")));
/* We ignore the CDROM prefix in that case */
snprintf(path, sizeof(path), "%s/setup.data/setup.xml", str);
if ( access( path, R_OK) ) {
/* Doesn't look like a setup archive */
gtk_label_set_text(GTK_LABEL(diag), _("Unable to identify an installation media."));
gtk_widget_hide(glade_xml_get_widget(rescue_glade, "media_select"));
return;
}
strncpy(root, str, sizeof(root));
} else {
/* Go through all CDROM devices and look for setup.xml files */
char *cds[SETUP_MAX_DRIVES];
int nb_drives = detect_and_mount_cdrom(cds), i;
for(i = 0; i < nb_drives; ++i ) {
snprintf(path, sizeof(path), "%s/%s/setup.data/setup.xml", cds[i], info->prefix);
if ( !access( path, R_OK) ) {
snprintf(root, sizeof(root), "%s/%s", cds[i], info->prefix);
break; /* FIXME: What if there are many setup CDs ? */
}
}
free_mounted_cdrom(nb_drives, cds);
}
/* Verify that the package is the same (product name and version) */
if ( ! check_xml_setup(path, info->name) ) {
gtk_label_set_text(GTK_LABEL(diag), _("Installation media doesn't match the product."));
gtk_widget_hide(glade_xml_get_widget(rescue_glade, "media_select"));
return;
}
gtk_label_set_text(GTK_LABEL(diag), _("Restoring files..."));
gtk_widget_realize(diag);
/* Fetch the files to be refreshed, i.e install with a restricted set of files */
install = create_install(path, info->root, NULL, info->prefix);
if ( install ) {
const char *f;
if ( chdir(root) < 0 ) {
fprintf(stderr, _("Unable to change to directory %s\n"), root);
} else {
/* Update the setup path */
strncpy(install->setup_path, root, sizeof(install->setup_path));
}
/* Check if we need to create a default component entry */
if ( GetProductNumComponents(install) == 0 ) {
current_component = add_component_entry(install, "Default", install->version, 1, NULL, NULL);
}
/* Restore any environment */
loki_put_envvars_component(loki_find_component(product, current_component->name));
/* Enable the relevant options */
select_corrupt_options(install);
copy_tree(install, install->config->root->childs, install->install_path, NULL);
/* Menu items are currently not being restored - maybe they should be tagged in setupdb ? */
/* Install the optional README and EULA files
Warning: those are always installed in the root of the installation directory!
*/
f = GetProductREADME(install, NULL);
if ( f && ! GetProductIsMeta(install) ) {
copy_path(install, f, install->install_path, NULL, 1, NULL, NULL);
}
f = GetProductEULA(install, NULL);
if ( f && ! GetProductIsMeta(install) ) {
copy_path(install, f, install->install_path, NULL, 1, NULL, NULL);
}
}
/* Print end message and disable the "Rescue" button */
gtk_label_set_text(GTK_LABEL(diag), _("Files successfully restored !"));
gtk_widget_set_sensitive(glade_xml_get_widget(check_glade, "rescue_button"), FALSE);
gtk_widget_hide(glade_xml_get_widget(rescue_glade, "media_select"));
message_dialog(_("Files successfully restored !"), _("Success"));
/* Unmount filesystems that may have been mounted */
unmount_filesystems();
}
