static int valid_arch_os(struct poldek_ts *ts, const tn_array *pkgs)
{
int i, nerr = 0;
for (i=0; i < n_array_size(pkgs); i++) {
struct pkg *pkg = n_array_nth(pkgs, i);
if (!poldek_conf_MULTILIB &&
!ts->getop(ts, POLDEK_OP_IGNOREARCH) && pkg->_arch &&
!pm_machine_score(ts->pmctx, PMMSTAG_ARCH, pkg_arch(pkg)))
{
logn(LOGERR, _("%s: package is for a different architecture (%s)"),
pkg_id(pkg), pkg_arch(pkg));
nerr++;
}
if (!ts->getop(ts, POLDEK_OP_IGNOREOS) && pkg->_os &&
!pm_machine_score(ts->pmctx, PMMSTAG_OS, pkg_os(pkg)))
{
logn(LOGERR, _("%s: package is for a different operating "
"system (%s)"), pkg_id(pkg), pkg_os(pkg));
nerr++;
}
}
return nerr == 0;
}
TextureMap::TextureMap(char *imagefile,int swrap,int twrap,
float (*filterfunc)(float,float,float,float),float swidth,float twidth)
{
Image image(imagefile);
int resolution;
int sres,tres,x,y;
int imagewidth,imageheight;
Colour col;
float *pixel;
imagewidth=image.Width();
imageheight=image.Height();
sres=(int)logn(2,imagewidth);
tres=(int)logn(2,imageheight);
this->maxresolution=MAX(sres,tres);
this->samples=3;
this->swrap=swrap;
this->twrap=twrap;
Allocate();
pixel=data[maxresolution];
for(y=0;y<imageheight;y++)
{
for(x=0;x<imagewidth;x++)
{
col=image.ReadColour(x,y);
*pixel++=col.r;
*pixel++=col.g;
*pixel++=col.b;
}
}
GenerateFilteredMaps();
}
int pdir_pkgdir_uniq(struct pkgdir *pkgdir)
{
int n = 0;
pkgdir->flags |= PKGDIR_UNIQED;
if (pkgdir->pkgs == NULL || n_array_size(pkgdir->pkgs) == 0)
return 0;
n = n_array_size(pkgdir->pkgs);
n_array_isort_ex(pkgdir->pkgs, (tn_fn_cmp)pkg_deepcmp_name_evr_rev);
n_array_uniq_ex(pkgdir->pkgs, (tn_fn_cmp)pdir_pkg_cmp_uniq_name_evr);
n -= n_array_size(pkgdir->pkgs);
if (n) {
char m[1024];
const char *name;
snprintf(m, sizeof(m), ngettext("removed %d duplicate package",
"removed %d duplicate packages", n), n);
name = pkgdir_idstr(pkgdir);
if (name)
logn(LOGWARN, "pdir: %s: %s", name, m);
else
logn(LOGWARN, "pdir: %s", m);
}
return n;
}
static
int add_alias(struct poclidek_ctx *cctx,
const char *aliasname, const char *cmdline)
{
struct poclidek_cmd *cmd, tmpcmd;
int rc = 1;
tmpcmd.name = (char*)aliasname;
if ((cmd = n_array_bsearch(cctx->commands, &tmpcmd)) == NULL) {
cmd = command_new_alias(aliasname, cmdline);
n_array_push(cctx->commands, cmd);
} else {
if ((cmd->flags & COMMAND_IS_ALIAS) == 0) {
logn(LOGWARN, _("%s: alias could not shadow a command"), aliasname);
rc = 0;
} else {
if (poldek_verbose() > 1)
logn(LOGWARN, _("%s (%s) overwrites %s"), aliasname, cmdline,
cmd->cmdline);
free(cmd->name);
cmd->name = n_strdup(aliasname);
free(cmd->cmdline);
cmd->cmdline = n_strdup(cmdline);
}
}
n_array_sort(cctx->commands);
return rc;
}
static
int pdir_pkg_cmp_uniq_name_evr(const struct pkg *p1, const struct pkg *p2)
{
register int rc;
#if ENABLE_TRACE
if (pkg_cmp_name_evr_rev(p1, p2) == 0)
logn(LOGNOTICE, "pdir: uniq %s: keep %s (score %d), removed %s (score %d)",
pkg_snprintf_s(p1), pkg_arch(p1), pkg_arch_score(p1),
pkg_arch(p2), pkg_archscore(p2));
#endif
rc = pkg_cmp_name_evr_rev(p1, p2);
if (rc == 0 && poldek_VERBOSE > 1) {
if (poldek_VERBOSE > 2) {
logn(LOGNOTICE, "pdir: uniq %s: keep %s (score %d), removed %s (score %d)",
pkg_snprintf_s(p1), pkg_arch(p1), pkg_arch_score(p1),
pkg_arch(p2), pkg_arch_score(p2));
} else {
logn(LOGWARN, _("pdir: %s%s%s: removed duplicate package"),
pkg_snprintf_s(p2), p2->_arch ? ".": "",
p2->_arch ? pkg_arch(p2): "");
}
}
return rc;
}
/**
* trie_print
* @t: trie to be printed
*
* Prints the trie to the log buffer.
*/
void
trie_print(struct f_trie *t)
{
char *sep = "";
logn("[");
if (t->zero)
{
logn("%I/%d", IPA_NONE, 0);
sep = ", ";
}
trie_node_print(&t->root, &sep);
logn("]");
}
static
int pndir_open_verify(struct pndir *idx, const char *path, int vfmode,
unsigned flags, const char *srcnam)
{
int rc;
DBGF("%s [%s]\n", path);
if (!pndir_open(idx, path, vfmode, flags, srcnam))
return 0;
rc = 1;
if (!tndb_verify(idx->db)) {
logn(LOGERR, "%s: broken file", vf_url_slim_s(idx->_vf->vf_path, 0));
rc = 0;
if (idx->_vf->vf_flags & VF_FRMCACHE) { /* not fully downloaded? */
n_assert(vfmode & VFM_CACHE);
vfmode &= ~VFM_CACHE;
vfmode |= VFM_NODEL;
pndir_close(idx);
return pndir_open_verify(idx, path, vfmode, flags, srcnam);
}
pndir_close(idx);
}
return rc;
}
static struct tndb *do_dbopen(const char *path, int vfmode, struct vfile **vf,
const char *srcnam)
{
struct vfile *vf_;
struct tndb *db;
int fd;
if (vf)
*vf = NULL;
if ((vf_ = vfile_open_ul(path, VFT_IO, vfmode, srcnam)) == NULL)
return NULL;
if ((fd = dup(vf_->vf_fd)) == -1) {
logn(LOGERR, "dup(%d): %m", vf_->vf_fd);
vfile_close(vf_);
return NULL;
}
if ((db = tndb_dopen(fd, vfile_localpath(vf_))) == NULL) {
vfile_close(vf_);
} else {
if (vf)
*vf = vf_;
else
vfile_close(vf_);
}
return db;
}
/* "access.log" in the log directory. */
void plog(char *str)
{
logn( PLAYER_LOG, str);
return;
}
static int verify_held_packages(struct i3ctx *ictx)
{
int i, j, rc = 1;
const tn_array *unpkgs;
if (poldek_ts_issetf(ictx->ts, POLDEK_TS_UPGRADE) == 0)
return 1;
if (ictx->ts->hold_patterns == NULL ||
!ictx->ts->getop(ictx->ts, POLDEK_OP_HOLD))
return 1;
unpkgs = iset_packages(ictx->unset);
for (i=0; i < n_array_size(unpkgs); i++) {
struct pkg *dbpkg;
struct pkgscore_s psc;
dbpkg = n_array_nth(unpkgs, i);
pkgscore_match_init(&psc, dbpkg);
for (j=0; j < n_array_size(ictx->ts->hold_patterns); j++) {
const char *mask = n_array_nth(ictx->ts->hold_patterns, j);
if (pkgscore_match(&psc, mask)) {
logn(LOGERR, _("%s: refusing to uninstall held package"),
pkg_id(dbpkg));
rc = 0;
break;
}
}
}
return rc;
}
static
Header do_loadrpmhdr(const char *path, int vfmode, const char *pdir_name)
{
struct vfile *vf = NULL;
tn_buf *nbuf;
tn_buf buf[4096];
int n;
Header h, ch = NULL;
if ((vf = vfile_open_ul(path, VFT_GZIO, vfmode, pdir_name)) == NULL)
return NULL;
nbuf = n_buf_new(1024 * 64);
while ((n = gzread(vf->vf_gzstream, buf, sizeof(buf))) > 0)
n_buf_write(nbuf, buf, n);
vfile_close(vf);
h = headerLoad(n_buf_ptr(nbuf)); /* rpm's memleak */
if (h == NULL) {
logn(LOGERR, "%s: load header failed", n_basenam(path));
} else if (headerIsEntry(h, RPMTAG_SOURCEPACKAGE)) { /* omit src.rpms */
h = NULL;
}
if (h)
ch = headerCopy(h);
n_buf_free(nbuf);
return ch;
}
static tn_hash *do_load_repomd(xmlNode *node)
{
tn_hash *repomd;
repomd = n_hash_new(16, (tn_fn_free)repomd_ent_free);
n_hash_ctl(repomd, TN_HASH_NOCPKEY);
for (; node; node = node->next) {
struct repomd_ent *ent;
if (node->type != XML_ELEMENT_NODE || strcmp((char *) node->name, "data") != 0)
continue;
if ((ent = load_repomd_ent(node))) {
n_hash_insert(repomd, ent->type, ent);
//printf("type = %s, loc = %s, ts = %ld\n", ent->type, ent->location, ent->ts);
}
}
if (n_hash_size(repomd) == 0 || !n_hash_exists(repomd, "primary")) {
logn(LOGERR, "repomd: empty or missing 'primary' entry");
n_hash_free(repomd);
repomd = NULL;
}
return repomd;
}
static int l_fs_read (lua_State *L) {
unsigned int fd = lua_tonumber(L, 1);
unsigned int count = lua_tonumber(L, 2);
size_t cur = lseek(fd, 0, SEEK_CUR);
size_t end = lseek(fd, 0, SEEK_END);
lseek(fd, cur, SEEK_SET);
if(count > end - cur)
count = end - cur;
void* buf = malloc(count);
size_t res = read(fd, buf, count);
logm("read(");
logi(fd);
logm(") bytes:");
logi(res);
logm(" of ");
logi(count);
logn("");
if(res > 0) {
lua_pushlstring(L, buf, res);
free(buf);
return 1;
}
free(buf);
return 0;
}
// konstruktor
Procesor::Procesor(int ID, int pocprc, const TVektor<int>& a, const TVektor<int>& b):ID(ID), pocprc(pocprc),plan(NULL),strom(NULL), a(a), b(b), obr_x(0), obr_y(0), obr(NULL), sbuffer(NULL), rbuffer(NULL)
{
//printf("init k-d tree...\n",ID, pocprc);
int hlbka = (int)logn((float)pocprc,(float)2);
strom=new KDTree(a,b,hlbka,0);
vytvorPlan(ID, strom->hlbka, strom->root, CVektor3(0,0,0)-CVektor3(2000,2000,2000), plan);
}
static int do_split(struct poldek_ctx *ctx, struct arg_s *arg_s)
{
if (arg_s->size < 50) {
logn(LOGERR, _("split size too small"));
return 0;
}
if (arg_s->size < arg_s->first_free_space) {
logn(LOGERR, _("first free space bigger than chunk size"));
return 0;
}
return poldek_split(ctx, arg_s->size, arg_s->first_free_space,
arg_s->prefix);
}
static
error_t parse_opt(int key, char *arg, struct argp_state *state)
{
struct poclidek_opgroup_rt *rt;
struct arg_s *arg_s;
rt = state->input;
if (rt->_opdata) {
arg_s = rt->_opdata;
} else {
arg_s = n_malloc(sizeof(*arg_s));
arg_s->cnflags = 0;
arg_s->size = arg_s->first_free_space = 0;
arg_s->prefix = NULL;
rt->_opdata = arg_s;
rt->_opdata_free = arg_s_free;
rt->run = oprun;
}
switch (key) {
case OPT_SPLITSIZE: {
char *p;
int rc;
if ((p = strrchr(arg, ':'))) {
rc = sscanf(arg, "%d:%d", &arg_s->size,
&arg_s->first_free_space);
rc = (rc == 2);
} else {
rc = sscanf(arg, "%d", &arg_s->size);
rc = (rc == 1);
}
if (rc)
arg_s->cnflags |= DO_SPLIT;
else {
logn(LOGERR, _("split: bad option argument"));
exit(EXIT_FAILURE);
}
}
break;
case OPT_SPLITCONF:
poldek_configure(rt->ctx, POLDEK_CONF_PRIFILE, arg);
break;
case OPT_SPLITPREFIX:
arg_s->prefix = n_strdup(arg);
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
static
struct pkguinf *load_pkguinf(tn_alloc *na, const struct pkg *pkg,
void *ptr, tn_array *langs)
{
struct pkguinf *pkgu = NULL;
char path[PATH_MAX];
Header h;
ptr = ptr; /* unused pkgdir_data */
snprintf(path, sizeof(path), "%s/%s", pkg->pkgdir->idxpath,
pkg_filename_s(pkg));
if (!is_rpmfile(path, NULL))
return NULL;
if (!pm_rpmhdr_loadfile(path, &h)) {
logn(LOGWARN, "%s: read header failed", n_basenam(path));
return NULL;
}
pkgu = pkguinf_ldrpmhdr(na, h, langs);
pm_rpmhdr_free(h);
return pkgu;
}
int pkgmark_verify_package_conflicts(struct pkgmark_set *pms)
{
tn_array *marked;
int i, j, nerr = 0;
marked = pkgmark_get_packages(pms, PKGMARK_MARK | PKGMARK_DEP);
for (i=0; i < n_array_size(marked); i++) {
struct pkg *pkg = n_array_nth(marked, i);
n_assert(pkg_is_marked(pms, pkg));
if (pkg->cnflpkgs == NULL)
continue;
for (j=0; j < n_array_size(pkg->cnflpkgs); j++) {
struct reqpkg *cpkg = n_array_nth(pkg->cnflpkgs, j);
if (pkg_is_marked(pms, cpkg->pkg)) {
logn(LOGERR, _("%s: conflicts with %s"), pkg_snprintf_s(pkg),
pkg_snprintf_s0(cpkg->pkg));
nerr++;
}
}
}
if (nerr)
msgn(0, _("%d conflicts found"), nerr);
n_array_free(marked);
return nerr == 0;
}
static int is_rpmfile(const char *path, struct stat *fst)
{
struct stat st;
if (stat(path, &st) != 0) {
logn(LOGERR, "stat %s: %m", path);
return 0;
}
if (!S_ISREG(st.st_mode)) {
logn(LOGERR, "%s: not a file", path);
return 0;
}
if (fst)
*fst = st;
return 1;
}
static
unsigned get_subopt(struct source *src, struct src_option *opt,
const char *str, const char *options_str)
{
unsigned v = 0;
n_assert(strncmp(str, opt->name, opt->len) == 0);
str += opt->len;
if (*str != '=') {
logn(LOGWARN, _("%s: %s unknown option"), options_str, str);
return 0;
}
str++;
if (opt->flag & PKGSOURCE_TYPE) {
src->type = n_strdup(str);
v = 1;
} else if (opt->flag & PKGSOURCE_DSCR) {
src->dscr = n_strdup(str);
v = 1;
} else if (opt->flag & PKGSOURCE_COMPRESS) {
src->compress = n_strdup(str);
v = 1;
} else if (opt->flag & PKGSOURCE_PRI) {
if (sscanf(str, "%d", &v) == 1) {
src->pri = v;
v = 1;
}
}
if (v == 0)
logn(LOGWARN, _("%s%sinvalid value ('%s') for option '%s'"),
src->name ? src->name : "", src->name ? ": " : "",
str, opt->name);
return v;
}
struct pkguinf *pkguinf_restore_rpmhdr_st(tn_alloc *na,
tn_stream *st, off_t offset)
{
uint16_t nsize, nlangs;
struct pkguinf *pkgu = NULL;
void *rawhdr;
Header hdr;
if (offset > 0)
if (n_stream_seek(st, offset, SEEK_SET) != 0) {
logn(LOGERR, "pkguinf_restore: fseek %ld: %m", (long int)offset);
return NULL;
}
if (!n_stream_read_uint16(st, &nlangs)) {
logn(LOGERR, "pkguinf_restore: read error nlangs (%m) at %ld %p",
n_stream_tell(st), st);
return NULL;
}
if (!n_stream_read_uint16(st, &nsize)) {
logn(LOGERR, "pkguinf_restore: read error nsize (%m) at %ld",
n_stream_tell(st));
return NULL;
}
rawhdr = alloca(nsize);
if (n_stream_read(st, rawhdr, nsize) != nsize) {
logn(LOGERR, "pkguinf_restore: read %d error at %ld", nsize,
n_stream_tell(st));
return NULL;
}
if ((hdr = headerLoad(rawhdr)) != NULL) {
pkgu = pkguinf_ldrpmhdr(na, hdr, NULL);
headerFree(hdr); //rpm's memleak
}
return pkgu;
}
TODO
static int valid_version(const char *ver, const char *path)
{
int major, minor;
if (sscanf(ver, "%u.%u", &major, &minor) != 2) {
logn(LOGERR, _("%s: invalid version string %s"), path, ver);
return 0;
}
if (major != FILEFMT_MAJOR)
logn(LOGERR, _("%s: unsupported version %s (%d.x is required)"),
path, ver, FILEFMT_MAJOR);
else if (minor > FILEFMT_MINOR)
logn(LOGERR, _("%s: unsupported version %s (upgrade the poldek)"),
path, ver);
return major == FILEFMT_MAJOR && minor <= FILEFMT_MINOR;
}
void balance(int id){
auto count = flat_tree.count(id);;
if (count > max_items_per_quad) {
int target_depth = get_depth(id) + logn(count, 4);
for (auto&a : query_quad(id)) {
//flat_tree.insert({})
insert(id, positions[id], target_depth);
}
flat_tree.erase(id); // erase all by key, can also erase iterator
}
}
int source_update(struct source *src, unsigned flags)
{
struct pkgdir *pkgdir;
int pcaps, rc = 0;
if (src->type == NULL)
source_set_type(src, poldek_conf_PKGDIR_DEFAULT_TYPE);
pcaps = pkgdir_type_info(src->type);
if ((pcaps & (PKGDIR_CAP_UPDATEABLE_INC | PKGDIR_CAP_UPDATEABLE)) == 0) {
logn(LOGWARN, _("%s: this type (%s) of source is not updateable"),
source_idstr(src), src->type);
} else if ((pcaps & PKGDIR_CAP_UPDATEABLE_INC) == 0) {
if (flags & (PKGSOURCE_UPA | PKGSOURCE_UPAUTOA))
return source_update_a(src);
logn(LOGWARN, _("%s: this type (%s) of source is not updateable; "
"use --upa to refresh it"),
source_idstr(src), src->type);
} else {
if ((flags & PKGSOURCE_UPA) && (flags & PKGSOURCE_UPAUTOA) == 0)
return source_update_a(src);
if (flags & PKGSOURCE_UPAUTOA)
src->flags |= PKGSOURCE_AUTOUPA;
pkgdir = pkgdir_srcopen(src, 0);
if (pkgdir != NULL) {
rc = pkgdir_update(pkgdir);
pkgdir_free(pkgdir);
}
}
return rc;
}
static
int pattern_compile(struct pattern *pt, int ntimes)
{
const char *pcre_err = NULL;
int pcre_err_off = 0;
n_assert(pt->pcre == NULL);
n_assert(pt->pcre_extra == NULL);
#ifdef FNM_CASEFOLD
pt->fnmatch_flags |= FNM_CASEFOLD;
#endif
if (pt->type != PATTERN_PCRE)
return 1;
pt->pcre = pcre_compile(pt->regexp, pt->pcre_flags, &pcre_err,
&pcre_err_off, pcre_chartable);
if (pt->pcre == NULL) {
logn(LOGERR, _("search: pattern: %s:%d: %s"), pt->regexp,
pcre_err_off, pcre_err);
return 0;
}
if (ntimes > 10) {
pcre_err = NULL;
pt->pcre_extra = pcre_study(pt->pcre, 0, &pcre_err);
if (pt->pcre_extra == NULL && pcre_err) {
logn(LOGERR, _("search: pattern study: %s: %s"), pt->regexp,
pcre_err);
return 0;
}
}
return 1;
}
static void
trie_node_print(struct f_trie_node *t, char **sep)
{
if (t == NULL)
return;
if (ipa_nonzero(t->accept))
{
logn("%s%I/%d{%I}", *sep, t->addr, t->plen, t->accept);
*sep = ", ";
}
trie_node_print(t->c[0], sep);
trie_node_print(t->c[1], sep);
}
int poldek_su(const char *user)
{
struct passwd pw, *pwptr;
char pwbuf[1024];
if (getpwnam_r(user, &pw, pwbuf, sizeof(pwbuf), &pwptr) != 0) {
logn(LOGERR, _("%s: could not retrieve account (%m)"), user);
return 0;
}
/* Make sure pw_shell is non-NULL. It may be NULL when NEW_USER
is a username that is retrieved via NIS (YP), but that doesn't have
a default shell listed. */
if (pw.pw_shell == NULL || pw.pw_shell[0] == '\0')
pw.pw_shell = "/bin/sh";
modify_environment(&pw);
if (setgid(pw.pw_gid) != 0) {
logn(LOGERR, _("setgid %s: %m"), user);
return 0;
}
if (setuid (pw.pw_uid) != 0) {
logn(LOGERR, _("setuid %s: %m"), user);
return 0;
}
if (chdir(pw.pw_dir) != 0) {
logn(LOGERR, _("chdir %s: %m"), pw.pw_dir);
return 0;
}
msgn(2, _("Running as user '%s'\n"), user);
return 1;
}
static Header make_pkguinf_hdr(struct pkguinf *pkgu, int *langs_cnt)
{
int i, nlangs = 0;
Header hdr = NULL;
unsigned hdr_size;
tn_array *langs;
hdr = headerNew();
if ((langs = pkgu->_langs_rpmhdr) == NULL)
langs = pkguinf_langs(pkgu);
for (i=0; i < n_array_size(langs); i++) {
const char *lang = n_array_nth(langs, i);
struct pkguinf_i18n *inf = n_hash_get(pkgu->_ht, lang);
headerAddI18NString(hdr, RPMTAG_SUMMARY, inf->summary, lang);
headerAddI18NString(hdr, RPMTAG_DESCRIPTION, inf->description, lang);
}
#if 0
if (pkgu->vendor)
headerAddEntry(hdr, RPMTAG_VENDOR, RPM_STRING_TYPE, pkgu->vendor, 1);
if (pkgu->license)
headerAddEntry(hdr, PM_RPMTAG_LICENSE, RPM_STRING_TYPE, pkgu->license, 1);
if (pkgu->url)
headerAddEntry(hdr, RPMTAG_URL, RPM_STRING_TYPE, pkgu->url, 1);
if (pkgu->distro)
headerAddEntry(hdr, RPMTAG_DISTRIBUTION, RPM_STRING_TYPE, pkgu->distro, 1);
if (pkgu->buildhost)
headerAddEntry(hdr, RPMTAG_BUILDHOST, RPM_STRING_TYPE, pkgu->buildhost, 1);
#endif
hdr_size = hacked_headerSizeof(hdr);
if (hdr_size > UINT16_MAX) {
logn(LOGERR, "internal: header size too large: %d", hdr_size);
headerFree(hdr);
hdr = NULL;
}
if (langs_cnt)
*langs_cnt = nlangs;
return hdr;
}
int poclidek_add_command(struct poclidek_ctx *cctx, struct poclidek_cmd *cmd)
{
cmd->_seqno = n_array_size(cctx->commands);
if (cmd->argp_opts)
translate_argp_options(cmd->argp_opts);
cmd->arg = _(cmd->arg);
cmd->doc = _(cmd->doc);
if (n_array_bsearch(cctx->commands, cmd)) {
logn(LOGERR, _("ambiguous command %s"), cmd->name);
return 0;
}
n_array_push(cctx->commands, cmd);
n_array_sort(cctx->commands);
return 1;
}
int source_cmp_uniq(const struct source *s1, const struct source *s2)
{
register int rc;
if ((rc = source_cmp(s1, s2)) == 0) {
const char *n1, *n2;
n1 = s1->type ? s1->type : "";
n2 = s2->type ? s2->type : "";
rc = strcmp(n1, n2);
}
if (rc == 0)
logn(LOGWARN, _("removed duplicated source %s%s%s"),
(s2->flags & PKGSOURCE_NAMED) ? s2->name : "",
(s2->flags & PKGSOURCE_NAMED) ? " -- " : "",
s2->path);
return rc;
}
