int OUTLINE::winding_num(Point pt) const{
Point vec = start_pos() - pt;
Point step_vec;
int cross_product;
int count = 0;
for (int i = 0; i < path_length(); ++i){
step_vec = step_dir(i);
if (vec.y <= 0 && vec.y + step_vec.y > 0){
cross_product = vec.cross_product(step_vec);
if (cross_product > 0) //ÓÒ±ßÏòÉÏ
++count;
else if (cross_product == 0)
return INTERSECTING;
}
else if (vec.y > 0 && vec.y + step_vec.y <= 0){
cross_product = vec.cross_product(step_vec);
if (cross_product < 0) //ÓÒ±ßÏòÏÂ
--count;
else if (cross_product == 0)
return INTERSECTING;
}
vec += step_vec;
}
return count;
}
VGfloat vgPathLength(VGPath path,
VGint startSegment,
VGint numSegments)
{
struct vg_context *ctx = vg_current_context();
struct path *p = 0;
if (path == VG_INVALID_HANDLE) {
vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
return -1;
}
if (startSegment < 0) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return -1;
}
if (numSegments <= 0) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return -1;
}
p = (struct path*)path;
if (!(path_capabilities(p) & VG_PATH_CAPABILITY_PATH_LENGTH)) {
vg_set_error(ctx, VG_PATH_CAPABILITY_ERROR);
return -1;
}
if (startSegment + numSegments > path_num_segments(p)) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return -1;
}
return path_length(p, startSegment, numSegments);
}
bool middle_point(PathType & path, double & x, double & y)
{
double x0 = 0;
double y0 = 0;
double x1 = 0;
double y1 = 0;
double mid_length = 0.5 * path_length(path);
path.rewind(0);
unsigned command = path.vertex(&x0,&y0);
if (command == SEG_END) return false;
double dist = 0.0;
while (SEG_END != (command = path.vertex(&x1, &y1)))
{
double seg_length = distance(x0, y0, x1, y1);
if ( dist + seg_length >= mid_length)
{
double r = (mid_length - dist)/seg_length;
x = x0 + (x1 - x0) * r;
y = y0 + (y1 - y0) * r;
break;
}
dist += seg_length;
x0 = x1;
y0 = y1;
}
return true;
}
int tlv_post_recv(struct tlv_extra *extra)
{
int result = 0;
struct management_tlv *mgt;
struct management_error_status *mes;
struct TLV *tlv = extra->tlv;
struct path_trace_tlv *ptt;
switch (tlv->type) {
case TLV_MANAGEMENT:
if (TLV_LENGTH_INVALID(tlv, management_tlv))
goto bad_length;
mgt = (struct management_tlv *) tlv;
mgt->id = ntohs(mgt->id);
if (tlv->length > sizeof(mgt->id))
result = mgt_post_recv(mgt, tlv->length - sizeof(mgt->id), extra);
break;
case TLV_MANAGEMENT_ERROR_STATUS:
if (TLV_LENGTH_INVALID(tlv, management_error_status))
goto bad_length;
mes = (struct management_error_status *) tlv;
mes->error = ntohs(mes->error);
mes->id = ntohs(mes->id);
break;
case TLV_ORGANIZATION_EXTENSION:
if (TLV_LENGTH_INVALID(tlv, organization_tlv))
goto bad_length;
result = org_post_recv((struct organization_tlv *) tlv);
break;
case TLV_REQUEST_UNICAST_TRANSMISSION:
case TLV_GRANT_UNICAST_TRANSMISSION:
case TLV_CANCEL_UNICAST_TRANSMISSION:
case TLV_ACKNOWLEDGE_CANCEL_UNICAST_TRANSMISSION:
break;
case TLV_PATH_TRACE:
ptt = (struct path_trace_tlv *) tlv;
if (path_length(ptt) > PATH_TRACE_MAX) {
ptt->length = PATH_TRACE_MAX * sizeof(struct ClockIdentity);
}
break;
case TLV_ALTERNATE_TIME_OFFSET_INDICATOR:
case TLV_AUTHENTICATION:
case TLV_AUTHENTICATION_CHALLENGE:
case TLV_SECURITY_ASSOCIATION_UPDATE:
case TLV_CUM_FREQ_SCALE_FACTOR_OFFSET:
case TLV_PTPMON_REQ:
break;
case TLV_PTPMON_RESP:
result = nsm_resp_post_recv(extra);
break;
default:
break;
}
return result;
bad_length:
return -EBADMSG;
}
bool path_iterate(const jsonpath *path, path_iterator iterator, void *context)
{
PRECOND_NONNULL_ELSE_FALSE(path, iterator);
for(size_t i = 0; i < path_length(path); i++)
{
if(!iterator(path->steps[i], context))
{
return false;
}
}
return true;
}
/**
* Identify dirname and basename of a path.
*
* @param[in] path, the path to be split up
* @param[out] dir, the directory part of path
* @param[out] base, the basename of path
*
* @return the length of input path
*
* NOTE! we force dir to be preallocated at minimum to length of path!!!
*/
PUBLIC u8
path_split (const path_t path, path_t dir, fid_t *base)
{
u8 l = path_length(path);
if (!l) return 0;
memcpy(DEST(dir), SRC(path), l * sizeof(*path));
dir[l-1] = EOP;
*base = path[l-1];
return l;
}
int main (int argc, char **argv)
{
point **ptoarr = malloc(4 * sizeof(point *));
*ptoarr = point_new(0.0, 0.0);
*(ptoarr + 1) = point_new(1.0, 0.0);
*(ptoarr + 2) = point_new(0.0, 0.0);
ptoarr[3] = point_new(1.0, 0.0);
path *p = path_new(ptoarr, 4);
path_show(p);
printf("The distance is %lf\n", path_length(p));
path_append(p, point_new(2.0, 2.0));
path_show(p);
return 0;
}
int OUTLINE::area() const{
Point pos = start_pos();
int total = 0;
for (int i = 0; i < path_length(); ++i){
DIR dir = step_dir(i);
Point dir_vec = dir;
if (dir_vec.x > 0)
total += pos.y;
else if (dir_vec.x < 0)
total -= pos.y;
pos += dir_vec;
}
return total;
}
// 'top_level' is extracting the file for a single-file torrent. The
// distinction is that the filename is found in "name" rather than
// "path"
// root_dir is the name of the torrent, unless this is a single file
// torrent, in which case it's empty.
bool extract_single_file(bdecode_node const& dict, file_storage& files
, std::string const& root_dir, ptrdiff_t info_ptr_diff, bool top_level
, int& pad_file_cnt, error_code& ec)
{
if (dict.type() != bdecode_node::dict_t) return false;
boost::uint32_t file_flags = get_file_attributes(dict);
// symlinks have an implied "size" of zero. i.e. they use up 0 bytes of
// the torrent payload space
boost::int64_t const file_size = (file_flags & file_storage::flag_symlink)
? 0
: dict.dict_find_int_value("length", -1);
if (file_size < 0 )
{
ec = errors::torrent_invalid_length;
return false;
}
boost::int64_t const mtime = dict.dict_find_int_value("mtime", 0);
std::string path = root_dir;
std::string path_element;
char const* filename = NULL;
int filename_len = 0;
if (top_level)
{
// prefer the name.utf-8 because if it exists, it is more likely to be
// correctly encoded
bdecode_node p = dict.dict_find_string("name.utf-8");
if (!p) p = dict.dict_find_string("name");
if (!p || p.string_length() == 0)
{
ec = errors::torrent_missing_name;
return false;
}
filename = p.string_ptr() + info_ptr_diff;
filename_len = p.string_length();
while (filename_len > 0 && filename[0] == TORRENT_SEPARATOR)
{
filename += 1;
filename_len -= 1;
}
sanitize_append_path_element(path, p.string_ptr(), p.string_length());
}
else
{
bdecode_node p = dict.dict_find_list("path.utf-8");
if (!p) p = dict.dict_find_list("path");
if (p && p.list_size() > 0)
{
std::size_t const orig_path_len = path.size();
int const preallocate = path.size() + path_length(p, ec);
if (ec) return false;
path.reserve(preallocate);
for (int i = 0, end(p.list_size()); i < end; ++i)
{
bdecode_node e = p.list_at(i);
if (i == end - 1)
{
filename = e.string_ptr() + info_ptr_diff;
filename_len = e.string_length();
}
while (filename_len > 0 && filename[0] == TORRENT_SEPARATOR)
{
filename += 1;
filename_len -= 1;
}
sanitize_append_path_element(path, e.string_ptr(), e.string_length());
}
// if all path elements were sanitized away, we need to use another
// name instead
if (path.size() == orig_path_len)
{
path += TORRENT_SEPARATOR;
path += "_";
}
}
else if (file_flags & file_storage::flag_pad_file)
{
// pad files don't need a path element, we'll just store them
// under the .pad directory
char cnt[10];
snprintf(cnt, sizeof(cnt), "%d", pad_file_cnt);
path = combine_path(".pad", cnt);
++pad_file_cnt;
}
else
{
ec = errors::torrent_missing_name;
return false;
}
}
// bitcomet pad file
if (path.find("_____padding_file_") != std::string::npos)
file_flags = file_storage::flag_pad_file;
bdecode_node fh = dict.dict_find_string("sha1");
char const* filehash = NULL;
if (fh && fh.string_length() == 20)
filehash = fh.string_ptr() + info_ptr_diff;
std::string symlink_path;
if (file_flags & file_storage::flag_symlink)
{
if (bdecode_node s_p = dict.dict_find_list("symlink path"))
{
int const preallocate = path_length(s_p, ec);
if (ec) return false;
symlink_path.reserve(preallocate);
for (int i = 0, end(s_p.list_size()); i < end; ++i)
{
bdecode_node const& n = s_p.list_at(i);
sanitize_append_path_element(symlink_path, n.string_ptr()
, n.string_length());
}
}
}
else
{
file_flags &= ~file_storage::flag_symlink;
}
if (filename_len > path.length()
|| path.compare(path.size() - filename_len, filename_len, filename
, filename_len) != 0)
{
// if the filename was sanitized and differ, clear it to just use path
filename = NULL;
filename_len = 0;
}
files.add_file_borrow(filename, filename_len, path, file_size, file_flags, filehash
, mtime, symlink_path);
return true;
}
evaluator_context *make_evaluator(const document_model *model, const jsonpath *path)
{
evaluator_debug("creating evaluator context");
evaluator_context *context = (evaluator_context *)calloc(1, sizeof(evaluator_context));
if(NULL == context)
{
evaluator_debug("uh oh! out of memory, can't allocate the evaluator context");
return NULL;
}
if(NULL == model)
{
evaluator_debug("model is null");
errno = EINVAL;
context->code = ERR_MODEL_IS_NULL;
return context;
}
if(NULL == path)
{
evaluator_debug("path is null");
errno = EINVAL;
context->code = ERR_PATH_IS_NULL;
return context;
}
if(NULL == model_document(model, 0))
{
evaluator_debug("document is null");
errno = EINVAL;
context->code = ERR_NO_DOCUMENT_IN_MODEL;
return context;
}
if(NULL == model_document_root(model, 0))
{
evaluator_debug("document root is null");
errno = EINVAL;
context->code = ERR_NO_ROOT_IN_DOCUMENT;
return context;
}
if(ABSOLUTE_PATH != path_kind(path))
{
evaluator_debug("path is not absolute");
errno = EINVAL;
context->code = ERR_PATH_IS_NOT_ABSOLUTE;
return context;
}
if(0 == path_length(path))
{
evaluator_debug("path is empty");
errno = EINVAL;
context->code = ERR_PATH_IS_EMPTY;
return context;
}
nodelist *list = make_nodelist();
if(NULL == list)
{
evaluator_debug("uh oh! out of memory, can't allocate the result nodelist");
context->code = ERR_EVALUATOR_OUT_OF_MEMORY;
return context;
}
context->list = list;
context->model = model;
context->path = path;
return context;
}
static int
archive_write_zip_close(struct archive_write *a)
{
struct zip *zip;
struct zip_file_header_link *l;
struct zip_file_header h;
struct zip_central_directory_end end;
struct zip_extra_data_central e;
int64_t offset_start, offset_end;
int entries;
int ret;
zip = a->format_data;
l = zip->central_directory;
/*
* Formatting central directory file header fields that are fixed for all entries.
* Fields not used (and therefor 0) are:
*
* - comment_length
* - disk_number
* - attributes_internal
*/
memset(&h, 0, sizeof(h));
archive_le32enc(&h.signature, ZIP_SIGNATURE_FILE_HEADER);
archive_le16enc(&h.version_by, ZIP_VERSION_BY);
archive_le16enc(&h.version_extract, ZIP_VERSION_EXTRACT);
entries = 0;
offset_start = zip->written_bytes;
/* Formatting individual header fields per entry and
* writing each entry. */
while (l != NULL) {
archive_le16enc(&h.flags, l->flags);
archive_le16enc(&h.compression, l->compression);
archive_le32enc(&h.timedate, dos_time(archive_entry_mtime(l->entry)));
archive_le32enc(&h.crc32, l->crc32);
archive_le32enc(&h.compressed_size, l->compressed_size);
archive_le32enc(&h.uncompressed_size, archive_entry_size(l->entry));
archive_le16enc(&h.filename_length, (uint16_t)path_length(l->entry));
archive_le16enc(&h.extra_length, sizeof(e));
archive_le16enc(&h.attributes_external[2], archive_entry_mode(l->entry));
archive_le32enc(&h.offset, l->offset);
/* Formatting extra data. */
archive_le16enc(&e.time_id, ZIP_SIGNATURE_EXTRA_TIMESTAMP);
archive_le16enc(&e.time_size, sizeof(e.mtime) + sizeof(e.time_flag));
e.time_flag[0] = 0x07;
archive_le32enc(&e.mtime, archive_entry_mtime(l->entry));
archive_le16enc(&e.unix_id, ZIP_SIGNATURE_EXTRA_NEW_UNIX);
archive_le16enc(&e.unix_size, 0x0000);
ret = __archive_write_output(a, &h, sizeof(h));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(h);
ret = write_path(l->entry, a);
if (ret <= ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += ret;
ret = __archive_write_output(a, &e, sizeof(e));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(e);
l = l->next;
entries++;
}
offset_end = zip->written_bytes;
/* Formatting end of central directory. */
memset(&end, 0, sizeof(end));
archive_le32enc(&end.signature, ZIP_SIGNATURE_CENTRAL_DIRECTORY_END);
archive_le16enc(&end.entries_disk, entries);
archive_le16enc(&end.entries, entries);
archive_le32enc(&end.size, offset_end - offset_start);
archive_le32enc(&end.offset, offset_start);
/* Writing end of central directory. */
ret = __archive_write_output(a, &end, sizeof(end));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(end);
return (ARCHIVE_OK);
}
inline int OUTLINE::perimeter() const{
int total = path_length();
return total;
}
static int
archive_write_zip_header(struct archive_write *a, struct archive_entry *entry)
{
struct zip *zip;
struct zip_local_file_header h;
struct zip_extra_data_local e;
struct zip_data_descriptor *d;
struct zip_file_header_link *l;
int ret;
int64_t size;
mode_t type;
/* Entries other than a regular file or a folder are skipped. */
type = archive_entry_filetype(entry);
if ((type != AE_IFREG) & (type != AE_IFDIR)) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, "Filetype not supported");
return ARCHIVE_FAILED;
};
/* Directory entries should have a size of 0. */
if (type == AE_IFDIR)
archive_entry_set_size(entry, 0);
zip = a->format_data;
d = &zip->data_descriptor;
size = archive_entry_size(entry);
zip->remaining_data_bytes = size;
/* Append archive entry to the central directory data. */
l = (struct zip_file_header_link *) malloc(sizeof(*l));
if (l == NULL) {
archive_set_error(&a->archive, ENOMEM, "Can't allocate zip header data");
return (ARCHIVE_FATAL);
}
l->entry = archive_entry_clone(entry);
/* Initialize the CRC variable and potentially the local crc32(). */
l->crc32 = crc32(0, NULL, 0);
l->compression = zip->compression;
l->compressed_size = 0;
l->next = NULL;
if (zip->central_directory == NULL) {
zip->central_directory = l;
} else {
zip->central_directory_end->next = l;
}
zip->central_directory_end = l;
/* Store the offset of this header for later use in central directory. */
l->offset = zip->written_bytes;
memset(&h, 0, sizeof(h));
archive_le32enc(&h.signature, ZIP_SIGNATURE_LOCAL_FILE_HEADER);
archive_le16enc(&h.version, ZIP_VERSION_EXTRACT);
archive_le16enc(&h.flags, ZIP_FLAGS);
archive_le16enc(&h.compression, zip->compression);
archive_le32enc(&h.timedate, dos_time(archive_entry_mtime(entry)));
archive_le16enc(&h.filename_length, (uint16_t)path_length(entry));
switch (zip->compression) {
case COMPRESSION_STORE:
/* Setting compressed and uncompressed sizes even when specification says
* to set to zero when using data descriptors. Otherwise the end of the
* data for an entry is rather difficult to find. */
archive_le32enc(&h.compressed_size, size);
archive_le32enc(&h.uncompressed_size, size);
break;
#ifdef HAVE_ZLIB_H
case COMPRESSION_DEFLATE:
archive_le32enc(&h.uncompressed_size, size);
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 = 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);
}
break;
#endif
}
/* Formatting extra data. */
archive_le16enc(&h.extra_length, sizeof(e));
archive_le16enc(&e.time_id, ZIP_SIGNATURE_EXTRA_TIMESTAMP);
archive_le16enc(&e.time_size, sizeof(e.time_flag) +
sizeof(e.mtime) + sizeof(e.atime) + sizeof(e.ctime));
e.time_flag[0] = 0x07;
archive_le32enc(&e.mtime, archive_entry_mtime(entry));
archive_le32enc(&e.atime, archive_entry_atime(entry));
archive_le32enc(&e.ctime, archive_entry_ctime(entry));
archive_le16enc(&e.unix_id, ZIP_SIGNATURE_EXTRA_UNIX);
archive_le16enc(&e.unix_size, sizeof(e.unix_uid) + sizeof(e.unix_gid));
archive_le16enc(&e.unix_uid, archive_entry_uid(entry));
archive_le16enc(&e.unix_gid, archive_entry_gid(entry));
archive_le32enc(&d->uncompressed_size, size);
ret = (a->compressor.write)(a, &h, sizeof(h));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(h);
ret = write_path(entry, a);
if (ret <= ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += ret;
ret = (a->compressor.write)(a, &e, sizeof(e));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(e);
return (ARCHIVE_OK);
}
static int
archive_write_zip_header(struct archive_write *a, struct archive_entry *entry)
{
struct zip *zip;
struct zip_local_file_header h;
struct zip_extra_data_local e;
struct zip_data_descriptor *d;
struct zip_file_header_link *l;
struct archive_string_conv *sconv;
int ret, ret2 = ARCHIVE_OK;
int64_t size;
mode_t type;
/* Entries other than a regular file or a folder are skipped. */
type = archive_entry_filetype(entry);
if ((type != AE_IFREG) & (type != AE_IFDIR)) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Filetype not supported");
return ARCHIVE_FAILED;
};
/* Directory entries should have a size of 0. */
if (type == AE_IFDIR)
archive_entry_set_size(entry, 0);
zip = a->format_data;
/* Setup default conversion. */
if (zip->opt_sconv == NULL && !zip->init_default_conversion) {
zip->sconv_default =
archive_string_default_conversion_for_write(&(a->archive));
zip->init_default_conversion = 1;
}
if (zip->flags == 0) {
/* Initialize the general purpose flags. */
zip->flags = ZIP_FLAGS;
if (zip->opt_sconv != NULL) {
if (strcmp(archive_string_conversion_charset_name(
zip->opt_sconv), "UTF-8") == 0)
zip->flags |= ZIP_FLAGS_UTF8_NAME;
#if HAVE_NL_LANGINFO
} else if (strcmp(nl_langinfo(CODESET), "UTF-8") == 0) {
zip->flags |= ZIP_FLAGS_UTF8_NAME;
#endif
}
}
d = &zip->data_descriptor;
size = archive_entry_size(entry);
zip->remaining_data_bytes = size;
/* Append archive entry to the central directory data. */
l = (struct zip_file_header_link *) malloc(sizeof(*l));
if (l == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate zip header data");
return (ARCHIVE_FATAL);
}
l->entry = archive_entry_clone(entry);
l->flags = zip->flags;
if (zip->opt_sconv != NULL)
sconv = zip->opt_sconv;
else
sconv = zip->sconv_default;
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(l->entry, p);
}
/* If all character of a filename is ASCII, Reset UTF-8 Name flag. */
if ((l->flags & ZIP_FLAGS_UTF8_NAME) != 0 &&
is_all_ascii(archive_entry_pathname(l->entry)))
l->flags &= ~ZIP_FLAGS_UTF8_NAME;
/* Initialize the CRC variable and potentially the local crc32(). */
l->crc32 = crc32(0, NULL, 0);
l->compression = zip->compression;
l->compressed_size = 0;
l->next = NULL;
if (zip->central_directory == NULL) {
zip->central_directory = l;
} else {
zip->central_directory_end->next = l;
}
zip->central_directory_end = l;
/* Store the offset of this header for later use in central directory. */
l->offset = zip->written_bytes;
memset(&h, 0, sizeof(h));
archive_le32enc(&h.signature, ZIP_SIGNATURE_LOCAL_FILE_HEADER);
archive_le16enc(&h.version, ZIP_VERSION_EXTRACT);
archive_le16enc(&h.flags, l->flags);
archive_le16enc(&h.compression, zip->compression);
archive_le32enc(&h.timedate, dos_time(archive_entry_mtime(entry)));
archive_le16enc(&h.filename_length, (uint16_t)path_length(l->entry));
switch (zip->compression) {
case COMPRESSION_STORE:
/* Setting compressed and uncompressed sizes even when specification says
* to set to zero when using data descriptors. Otherwise the end of the
* data for an entry is rather difficult to find. */
archive_le32enc(&h.compressed_size, size);
archive_le32enc(&h.uncompressed_size, size);
break;
#ifdef HAVE_ZLIB_H
case COMPRESSION_DEFLATE:
archive_le32enc(&h.uncompressed_size, size);
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 = 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);
}
break;
#endif
}
/* Formatting extra data. */
archive_le16enc(&h.extra_length, sizeof(e));
archive_le16enc(&e.time_id, ZIP_SIGNATURE_EXTRA_TIMESTAMP);
archive_le16enc(&e.time_size, sizeof(e.time_flag) +
sizeof(e.mtime) + sizeof(e.atime) + sizeof(e.ctime));
e.time_flag[0] = 0x07;
archive_le32enc(&e.mtime, archive_entry_mtime(entry));
archive_le32enc(&e.atime, archive_entry_atime(entry));
archive_le32enc(&e.ctime, archive_entry_ctime(entry));
archive_le16enc(&e.unix_id, ZIP_SIGNATURE_EXTRA_NEW_UNIX);
archive_le16enc(&e.unix_size, sizeof(e.unix_version) +
sizeof(e.unix_uid_size) + sizeof(e.unix_uid) +
sizeof(e.unix_gid_size) + sizeof(e.unix_gid));
e.unix_version = 1;
e.unix_uid_size = 4;
archive_le32enc(&e.unix_uid, archive_entry_uid(entry));
e.unix_gid_size = 4;
archive_le32enc(&e.unix_gid, archive_entry_gid(entry));
archive_le32enc(&d->uncompressed_size, size);
ret = __archive_write_output(a, &h, sizeof(h));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(h);
ret = write_path(l->entry, a);
if (ret <= ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += ret;
ret = __archive_write_output(a, &e, sizeof(e));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(e);
if (ret2 != ARCHIVE_OK)
return (ret2);
return (ARCHIVE_OK);
}
Genome(vector<int> path, Graph &G) {
this->genes = path;
this->G = G;
this->score = path_length();
}
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);
}
static int
archive_write_zip_header(struct archive_write *a, struct archive_entry *entry)
{
struct zip *zip;
uint8_t h[SIZE_LOCAL_FILE_HEADER];
uint8_t e[SIZE_EXTRA_DATA_LOCAL];
uint8_t *d;
struct zip_file_header_link *l;
struct archive_string_conv *sconv;
int ret, ret2 = ARCHIVE_OK;
int64_t size;
mode_t type;
/* Entries other than a regular file or a folder are skipped. */
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;
};
/* Directory entries should have a size of 0. */
if (type == AE_IFDIR)
archive_entry_set_size(entry, 0);
zip = a->format_data;
/* Setup default conversion. */
if (zip->opt_sconv == NULL && !zip->init_default_conversion) {
zip->sconv_default =
archive_string_default_conversion_for_write(&(a->archive));
zip->init_default_conversion = 1;
}
if (zip->flags == 0) {
/* Initialize the general purpose flags. */
zip->flags = ZIP_FLAGS;
if (zip->opt_sconv != NULL) {
if (strcmp(archive_string_conversion_charset_name(
zip->opt_sconv), "UTF-8") == 0)
zip->flags |= ZIP_FLAGS_UTF8_NAME;
#if HAVE_NL_LANGINFO
} else if (strcmp(nl_langinfo(CODESET), "UTF-8") == 0) {
zip->flags |= ZIP_FLAGS_UTF8_NAME;
#endif
}
}
d = zip->data_descriptor;
size = archive_entry_size(entry);
zip->remaining_data_bytes = size;
/* Append archive entry to the central directory data. */
l = (struct zip_file_header_link *) malloc(sizeof(*l));
if (l == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate zip header data");
return (ARCHIVE_FATAL);
}
#if defined(_WIN32) && !defined(__CYGWIN__)
/* Make sure the path separators in pahtname, hardlink and symlink
* are all slash '/', not the Windows path separator '\'. */
l->entry = __la_win_entry_in_posix_pathseparator(entry);
if (l->entry == entry)
l->entry = archive_entry_clone(entry);
#else
l->entry = archive_entry_clone(entry);
#endif
if (l->entry == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate zip header data");
free(l);
return (ARCHIVE_FATAL);
}
l->flags = zip->flags;
if (zip->opt_sconv != NULL)
sconv = zip->opt_sconv;
else
sconv = zip->sconv_default;
if (sconv != NULL) {
const char *p;
size_t len;
if (archive_entry_pathname_l(entry, &p, &len, sconv) != 0) {
if (errno == ENOMEM) {
archive_entry_free(l->entry);
free(l);
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(l->entry, p);
/*
* Although there is no character-set regulation for Symlink,
* it is suitable to convert a character-set of Symlinke to
* what those of the Pathname has been converted to.
*/
if (type == AE_IFLNK) {
if (archive_entry_symlink_l(entry, &p, &len, sconv)) {
if (errno == ENOMEM) {
archive_entry_free(l->entry);
free(l);
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory "
" for Symlink");
return (ARCHIVE_FATAL);
}
/*
* Even if the strng conversion failed,
* we should not report the error since
* thre is no regulation for.
*/
} else if (len > 0)
archive_entry_set_symlink(l->entry, p);
}
}
/* If all characters in a filename are ASCII, Reset UTF-8 Name flag. */
if ((l->flags & ZIP_FLAGS_UTF8_NAME) != 0 &&
is_all_ascii(archive_entry_pathname(l->entry)))
l->flags &= ~ZIP_FLAGS_UTF8_NAME;
/* Initialize the CRC variable and potentially the local crc32(). */
l->crc32 = crc32(0, NULL, 0);
if (type == AE_IFLNK) {
const char *p = archive_entry_symlink(l->entry);
if (p != NULL)
size = strlen(p);
else
size = 0;
zip->remaining_data_bytes = 0;
archive_entry_set_size(l->entry, size);
l->compression = COMPRESSION_STORE;
l->compressed_size = size;
} else {
l->compression = zip->compression;
l->compressed_size = 0;
}
l->next = NULL;
if (zip->central_directory == NULL) {
zip->central_directory = l;
} else {
zip->central_directory_end->next = l;
}
zip->central_directory_end = l;
/* Store the offset of this header for later use in central
* directory. */
l->offset = zip->written_bytes;
memset(h, 0, sizeof(h));
archive_le32enc(&h[LOCAL_FILE_HEADER_SIGNATURE],
ZIP_SIGNATURE_LOCAL_FILE_HEADER);
archive_le16enc(&h[LOCAL_FILE_HEADER_VERSION], ZIP_VERSION_EXTRACT);
archive_le16enc(&h[LOCAL_FILE_HEADER_FLAGS], l->flags);
archive_le16enc(&h[LOCAL_FILE_HEADER_COMPRESSION], l->compression);
archive_le32enc(&h[LOCAL_FILE_HEADER_TIMEDATE],
dos_time(archive_entry_mtime(entry)));
archive_le16enc(&h[LOCAL_FILE_HEADER_FILENAME_LENGTH],
(uint16_t)path_length(l->entry));
switch (l->compression) {
case COMPRESSION_STORE:
/* Setting compressed and uncompressed sizes even when
* specification says to set to zero when using data
* descriptors. Otherwise the end of the data for an
* entry is rather difficult to find. */
archive_le32enc(&h[LOCAL_FILE_HEADER_COMPRESSED_SIZE],
(uint32_t)size);
archive_le32enc(&h[LOCAL_FILE_HEADER_UNCOMPRESSED_SIZE],
(uint32_t)size);
break;
#ifdef HAVE_ZLIB_H
case COMPRESSION_DEFLATE:
archive_le32enc(&h[LOCAL_FILE_HEADER_UNCOMPRESSED_SIZE],
(uint32_t)size);
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);
}
break;
#endif
}
/* Formatting extra data. */
archive_le16enc(&h[LOCAL_FILE_HEADER_EXTRA_LENGTH], sizeof(e));
archive_le16enc(&e[EXTRA_DATA_LOCAL_TIME_ID],
ZIP_SIGNATURE_EXTRA_TIMESTAMP);
archive_le16enc(&e[EXTRA_DATA_LOCAL_TIME_SIZE], 1 + 4 * 3);
e[EXTRA_DATA_LOCAL_TIME_FLAG] = 0x07;
archive_le32enc(&e[EXTRA_DATA_LOCAL_MTIME],
(uint32_t)archive_entry_mtime(entry));
archive_le32enc(&e[EXTRA_DATA_LOCAL_ATIME],
(uint32_t)archive_entry_atime(entry));
archive_le32enc(&e[EXTRA_DATA_LOCAL_CTIME],
(uint32_t)archive_entry_ctime(entry));
archive_le16enc(&e[EXTRA_DATA_LOCAL_UNIX_ID],
ZIP_SIGNATURE_EXTRA_NEW_UNIX);
archive_le16enc(&e[EXTRA_DATA_LOCAL_UNIX_SIZE], 1 + (1 + 4) * 2);
e[EXTRA_DATA_LOCAL_UNIX_VERSION] = 1;
e[EXTRA_DATA_LOCAL_UNIX_UID_SIZE] = 4;
archive_le32enc(&e[EXTRA_DATA_LOCAL_UNIX_UID],
(uint32_t)archive_entry_uid(entry));
e[EXTRA_DATA_LOCAL_UNIX_GID_SIZE] = 4;
archive_le32enc(&e[EXTRA_DATA_LOCAL_UNIX_GID],
(uint32_t)archive_entry_gid(entry));
archive_le32enc(&d[DATA_DESCRIPTOR_UNCOMPRESSED_SIZE],
(uint32_t)size);
ret = __archive_write_output(a, h, sizeof(h));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(h);
ret = write_path(l->entry, a);
if (ret <= ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += ret;
ret = __archive_write_output(a, e, sizeof(e));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(e);
if (type == AE_IFLNK) {
const unsigned char *p;
p = (const unsigned char *)archive_entry_symlink(l->entry);
ret = __archive_write_output(a, p, (size_t)size);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += size;
l->crc32 = crc32(l->crc32, p, (unsigned)size);
}
if (ret2 != ARCHIVE_OK)
return (ret2);
return (ARCHIVE_OK);
}
entry_t *readstate(void)
/* Read one entry from the state file. */
{
static entry_t entry;
static pathname_t path;
static size_t *trunc;
static size_t trunc_len;
static base_indent;
char *line;
char **argv;
size_t argc;
static off_t lineno;
int indent, depth;
recurse:
keep= KEEP_STATE;
if (feof(statefp) || (line= read1line(statefp)) == nil) {
checkstate();
return nil;
}
lineno++;
/* How far is this entry indented? */
indent= 0;
while (*line != 0) {
if (*line == ' ') indent++;
else
if (*line == '\t') indent= (indent + 8) & ~7;
else
break;
line++;
}
if (indent > 0 && base_indent == 0) base_indent= indent;
depth= (base_indent == 0 ? 0 : indent / base_indent) + 1;
if (entry.ignore && depth > entry.depth) {
/* If the old directory is ignored, then so are its entries. */
goto recurse;
}
entry.depth= depth;
splitline(line, &argv, &argc);
if (argc < 2) state_syntax(lineno);
if (trunc == nil) {
/* The root of the tree, initialize path. */
if (argv[0][0] != '/') state_syntax(lineno);
path_init(&path);
path_add(&path, "/");
trunc= allocate(nil, (trunc_len= 16) * sizeof(trunc[0]));
/* The root has depth 0. */
entry.depth= 0;
trunc[0]= 0;
} else {
if (entry.depth > trunc_len) {
trunc= allocate(trunc,
(trunc_len*= 2) * sizeof(trunc[0]));
}
path_trunc(&path, trunc[entry.depth - 1]);
path_add(&path, argv[0]);
trunc[entry.depth]= path_length(&path);
}
entry.path= path_name(&path);
entry.name= argv[0];
entry.link= nil;
if ((entry.ignore= strcmp(argv[1], "ignore") == 0)) {
return &entry;
}
if (!getattributes(&entry, argc - 1, argv + 1)) state_syntax(lineno);
return &entry;
}
entry_t *traverse(void)
/* Get one name from the directory tree. */
{
static int depth;
static pathname_t path;
static entry_t entry;
static namelist_t **entries;
static size_t *trunc;
static size_t deep;
static namelist_t *newentries;
struct stat st;
recurse:
keep= KEEP_TRAVERSE;
if (deep == 0) {
/* Initialize for the root of the tree. */
path_init(&path);
path_add(&path, tree);
entries= allocate(nil, 1 * sizeof(entries[0]));
entries[0]= allocate(nil, sizeof(*entries[0]));
entries[0]->next= nil;
entries[0]->name= copystr("/");
trunc= allocate(nil, 1 * sizeof(trunc[0]));
trunc[0]= path_length(&path);
deep= 1;
} else
if (newentries != nil) {
/* Last entry was a directory, need to go down. */
if (entry.ignore) {
/* Ouch, it is to be ignored! */
while (newentries != nil) (void) pop_name(&newentries);
goto recurse;
}
if (++depth == deep) {
deep++;
entries= allocate(entries, deep * sizeof(entries[0]));
trunc= allocate(trunc, deep * sizeof(trunc[0]));
}
entries[depth]= newentries;
newentries= nil;
trunc[depth]= path_length(&path);
} else {
/* Pop up out of emptied directories. */
while (entries[depth] == nil) {
if (depth == 0) return nil; /* Back at the root. */
/* Go up one level. */
depth--;
}
}
entry.name= pop_name(&entries[depth]);
path_trunc(&path, trunc[depth]);
path_add(&path, entry.name);
if (depth == 0) {
entry.path= "/";
} else {
entry.path= path_name(&path) + trunc[0];
if (entry.path[0] == '/') entry.path++;
}
entry.depth= depth;
entry.ignore= 0;
if (lstat(path_name(&path), &st) < 0) {
if (depth == 0 || errno != ENOENT) {
/* Something wrong with this entry, complain about
* it and ignore it further.
*/
entry.ignore= errno;
report(path_name(&path));
return &entry;
} else {
/* Entry strangely nonexistent; simply continue. */
goto recurse;
}
}
/* Don't cross mountpoints if -x is set. */
if (xflag) {
if (xdev == NO_DEVICE) xdev= st.st_dev;
if (st.st_dev != xdev) {
/* Ignore the mountpoint. */
entry.ignore= EXDEV;
return &entry;
}
}
entry.mode= st.st_mode & 07777;
entry.uid= st.st_uid;
entry.gid= st.st_gid;
entry.size= st.st_size;
entry.mtime= st.st_mtime;
entry.rdev= st.st_rdev;
linked(&entry, &st);
if (S_ISDIR(st.st_mode)) {
/* A directory. */
entry.type= F_DIR;
/* Gather directory entries for the next traverse. */
if ((newentries= collect(path_name(&path))) == nil
&& errno != 0) {
entry.ignore= errno;
report(path_name(&path));
}
} else
if (S_ISREG(st.st_mode)) {
/* A plain file. */
entry.type= F_FILE;
} else
if (S_ISBLK(st.st_mode)) {
/* A block special file. */
entry.type= F_BLK;
} else
if (S_ISCHR(st.st_mode)) {
/* A character special file. */
entry.type= F_CHR;
} else
if (S_ISFIFO(st.st_mode)) {
/* A named pipe. */
entry.type= F_PIPE;
} else
if (S_ISLNK(st.st_mode)) {
/* A symbolic link. */
entry.type= F_LINK;
if ((entry.link= rdlink(path_name(&path), st.st_size)) == nil) {
entry.ignore= errno;
report(path_name(&path));
}
} else {
/* Unknown type of file. */
entry.ignore= EINVAL;
}
return &entry;
}
static int
archive_write_zip_close(struct archive_write *a)
{
struct zip *zip;
struct zip_file_header_link *l;
uint8_t h[SIZE_FILE_HEADER];
uint8_t end[SIZE_CENTRAL_DIRECTORY_END];
uint8_t e[SIZE_EXTRA_DATA_CENTRAL];
int64_t offset_start, offset_end;
int entries;
int ret;
zip = a->format_data;
l = zip->central_directory;
/*
* Formatting central directory file header fields that are
* fixed for all entries.
* Fields not used (and therefor 0) are:
*
* - comment_length
* - disk_number
* - attributes_internal
*/
memset(h, 0, sizeof(h));
archive_le32enc(&h[FILE_HEADER_SIGNATURE], ZIP_SIGNATURE_FILE_HEADER);
archive_le16enc(&h[FILE_HEADER_VERSION_BY], ZIP_VERSION_BY);
archive_le16enc(&h[FILE_HEADER_VERSION_EXTRACT], ZIP_VERSION_EXTRACT);
entries = 0;
offset_start = zip->written_bytes;
/* Formatting individual header fields per entry and
* writing each entry. */
while (l != NULL) {
archive_le16enc(&h[FILE_HEADER_FLAGS], l->flags);
archive_le16enc(&h[FILE_HEADER_COMPRESSION], l->compression);
archive_le32enc(&h[FILE_HEADER_TIMEDATE],
dos_time(archive_entry_mtime(l->entry)));
archive_le32enc(&h[FILE_HEADER_CRC32], l->crc32);
archive_le32enc(&h[FILE_HEADER_COMPRESSED_SIZE],
(uint32_t)l->compressed_size);
archive_le32enc(&h[FILE_HEADER_UNCOMPRESSED_SIZE],
(uint32_t)archive_entry_size(l->entry));
archive_le16enc(&h[FILE_HEADER_FILENAME_LENGTH],
(uint16_t)path_length(l->entry));
archive_le16enc(&h[FILE_HEADER_EXTRA_LENGTH], sizeof(e));
archive_le16enc(&h[FILE_HEADER_ATTRIBUTES_EXTERNAL+2],
archive_entry_mode(l->entry));
archive_le32enc(&h[FILE_HEADER_OFFSET], (uint32_t)l->offset);
/* Formatting extra data. */
archive_le16enc(&e[EXTRA_DATA_CENTRAL_TIME_ID],
ZIP_SIGNATURE_EXTRA_TIMESTAMP);
archive_le16enc(&e[EXTRA_DATA_CENTRAL_TIME_SIZE], 1 + 4);
e[EXTRA_DATA_CENTRAL_TIME_FLAG] = 0x07;
archive_le32enc(&e[EXTRA_DATA_CENTRAL_MTIME],
(uint32_t)archive_entry_mtime(l->entry));
archive_le16enc(&e[EXTRA_DATA_CENTRAL_UNIX_ID],
ZIP_SIGNATURE_EXTRA_NEW_UNIX);
archive_le16enc(&e[EXTRA_DATA_CENTRAL_UNIX_SIZE], 0x0000);
ret = __archive_write_output(a, h, sizeof(h));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(h);
ret = write_path(l->entry, a);
if (ret <= ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += ret;
ret = __archive_write_output(a, e, sizeof(e));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(e);
l = l->next;
entries++;
}
offset_end = zip->written_bytes;
/* Formatting end of central directory. */
memset(end, 0, sizeof(end));
archive_le32enc(&end[CENTRAL_DIRECTORY_END_SIGNATURE],
ZIP_SIGNATURE_CENTRAL_DIRECTORY_END);
archive_le16enc(&end[CENTRAL_DIRECTORY_END_ENTRIES_DISK], entries);
archive_le16enc(&end[CENTRAL_DIRECTORY_END_ENTRIES], entries);
archive_le32enc(&end[CENTRAL_DIRECTORY_END_SIZE],
(uint32_t)(offset_end - offset_start));
archive_le32enc(&end[CENTRAL_DIRECTORY_END_OFFSET],
(uint32_t)offset_start);
/* Writing end of central directory. */
ret = __archive_write_output(a, end, sizeof(end));
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
zip->written_bytes += sizeof(end);
return (ARCHIVE_OK);
}
// CLASS FUNCTIONS
std::vector<MapNode*> JPS::get_path
(
Map* map,
MapNode* start,
MapNode* end
)
{
start->set_data<AStarNodeData>(new AStarNodeData(0, heuristic(start,end)));
m_open_set.insert(start);
m_open_queue.push(start);
AStarNodeData* s_data = start->get_data<AStarNodeData>();
std::unordered_map<MapNode*,MapNode*> came_from;
// The return path
std::vector<MapNode*> path;
while (m_open_queue.size() > 0)
{
// Get the first item in the min-heap
MapNode* current = m_open_queue.top();
m_open_set.erase(current);
m_open_queue.pop();
AStarNodeData* c_data = current->get_data<AStarNodeData>();
// Short-circuit for the end
if (!current->is_seen() && c_data->f_score() < s_data->f_score())
{
int dist = path_length(current, end);
if (AStarNodeData* data = end->get_data<AStarNodeData>())
{
data->g_score = data->g_score + dist;
data->h_score = 0;
}
else
{
end->set_data<AStarNodeData>(
new AStarNodeData(c_data->g_score + dist, 0)
);
}
path = reconstruct_path(came_from, current);
break;
}
if (current == end)
{
path = reconstruct_path(came_from, end);
break;
}
m_closed_set.insert(current);
for (MapNode* neighbor : get_successors(map, current, end))
{
bool is_in_open_set = m_open_set.find(neighbor) != m_open_set.end();
bool is_in_closed_set = m_closed_set.find(neighbor) != m_closed_set.end();
// If it's in the closed set skip
if (is_in_closed_set)
{
continue; // Ignore the neighbor which is already evaluated.
}
AStarNodeData* n_data = neighbor->get_data<AStarNodeData>();
// The distance from start to goal passing through current and the neighbor.
int tentative_g_score = c_data->g_score + path_length(current,neighbor);
if (is_in_open_set && tentative_g_score >= n_data->g_score)
{
continue; // This is not a better path.
}
// This path is the best until now. Record it!
came_from[neighbor] = current;
if (n_data)
{
n_data->g_score = tentative_g_score;
n_data->h_score = heuristic(neighbor, end);
}
else
{
neighbor->set_data<AStarNodeData>(
new AStarNodeData(
tentative_g_score,
heuristic(neighbor, end)
)
);
}
if (!is_in_open_set)
{
m_open_set.insert(neighbor);
m_open_queue.push(neighbor);
}
}
}
return path;
}
