static void aux_sp_delete(void *node)
{
ss_free(&((struct SMapSP *)node)->x.k);
}
/**
free workspace and return a sparse matrix result */
static cs *ss_done (cs *C, void *w, void *x, SS_INT ok)
{
ss_free (w) ; /* free workspace */
ss_free (x) ;
return (ok ? C : ss_spfree (C)) ; /* return result if OK, else free it */
}
static void aux_ss_delete(void *node)
{
ss_free(&((struct SMapSS *)node)->x.k, &((struct SMapIS *)node)->v);
}
int si_schemerecover(sischeme *s, sr *r)
{
sdscheme c;
sd_schemeinit(&c);
char path[PATH_MAX];
snprintf(path, sizeof(path), "%s/scheme", s->path);
int version_storage_set = 0;
int rc;
rc = sd_schemerecover(&c, r, path);
if (ssunlikely(rc == -1))
goto error;
ssiter i;
ss_iterinit(sd_schemeiter, &i);
rc = ss_iteropen(sd_schemeiter, &i, r, &c, 1);
if (ssunlikely(rc == -1))
goto error;
while (ss_iterhas(sd_schemeiter, &i))
{
sdschemeopt *opt = ss_iterof(sd_schemeiter, &i);
switch (opt->id) {
case SI_SCHEME_VERSION:
break;
case SI_SCHEME_VERSION_STORAGE: {
if (opt->size != sizeof(srversion))
goto error;
srversion *version = (srversion*)sd_schemesz(opt);
if (! sr_versionstorage_check(version))
goto error_format;
version_storage_set = 1;
break;
}
case SI_SCHEME_FORMAT_STORAGE:
s->fmt_storage = sd_schemeu32(opt);
break;
case SI_SCHEME_SCHEME: {
sf_schemefree(&s->scheme, r->a);
sf_schemeinit(&s->scheme);
ssbuf buf;
ss_bufinit(&buf);
rc = sf_schemeload(&s->scheme, r->a, sd_schemesz(opt), opt->size);
if (ssunlikely(rc == -1))
goto error;
rc = sf_schemevalidate(&s->scheme, r->a);
if (ssunlikely(rc == -1))
goto error;
ss_buffree(&buf, r->a);
break;
}
case SI_SCHEME_NODE_SIZE:
s->node_size = sd_schemeu64(opt);
break;
case SI_SCHEME_NODE_PAGE_SIZE:
s->node_page_size = sd_schemeu32(opt);
break;
case SI_SCHEME_COMPRESSION_KEY:
s->compression_key = sd_schemeu32(opt);
break;
case SI_SCHEME_COMPRESSION: {
char *name = sd_schemesz(opt);
ssfilterif *cif = ss_filterof(name);
if (ssunlikely(cif == NULL))
goto error;
s->compression_if = cif;
s->compression = s->compression_if != &ss_nonefilter;
ss_free(r->a, s->compression_sz);
s->compression_sz = ss_strdup(r->a, cif->name);
if (ssunlikely(s->compression_sz == NULL))
goto error;
break;
}
case SI_SCHEME_COMPRESSION_BRANCH: {
char *name = sd_schemesz(opt);
ssfilterif *cif = ss_filterof(name);
if (ssunlikely(cif == NULL))
goto error;
s->compression_branch_if = cif;
s->compression_branch = s->compression_branch_if != &ss_nonefilter;
ss_free(r->a, s->compression_branch_sz);
s->compression_branch_sz = ss_strdup(r->a, cif->name);
if (ssunlikely(s->compression_branch_sz == NULL))
goto error;
break;
}
case SI_SCHEME_AMQF:
s->amqf = sd_schemeu32(opt);
break;
case SI_SCHEME_EXPIRE:
s->expire = sd_schemeu32(opt);
break;
default: /* skip unknown */
break;
}
ss_iternext(sd_schemeiter, &i);
}
if (ssunlikely(! version_storage_set))
goto error_format;
sd_schemefree(&c, r);
return 0;
error_format:
sr_error(r->e, "%s", "incompatible storage format version");
error:
sd_schemefree(&c, r);
return -1;
}
int main(int argc, const char **argv)
{
size_t in_size = 0, enc_bytes, rgb1_bytes, rgb2_bytes;
ssize_t written;
struct RGB_Info ri1, ri2;
srt_string *iobuf = NULL, *rgb1_buf = NULL, *rgb2_buf = NULL,
*rgb3_buf = NULL;
int exit_code = 2;
FILE *fin = NULL, *fout = NULL;
const char *exit_msg = "not enough parameters";
srt_bool ro;
enum ImgTypes t_in1, t_in2, t_out;
#define IMGC_XTEST(test, m, c) \
if (test) { \
exit_msg = m; \
exit_code = c; \
break; \
}
for (;;) {
if (argc < 2)
break;
ro = argc < 3 ? S_TRUE : S_FALSE;
t_in1 = file_type(argv[1]);
t_in2 = file_type(argv[2]);
t_out = argc < 4 ? IMG_none : file_type(argv[3]);
IMGC_XTEST(t_in1 == IMG_error || t_in2 == IMG_error
|| t_out == IMG_error,
"invalid parameters",
t_in1 == IMG_error || t_in2 == IMG_error ? 3 : 4);
fin = fopen(argv[1], "rb");
iobuf = ss_dup_read(fin, MAX_FILE_SIZE);
in_size = ss_size(iobuf);
IMGC_XTEST(!in_size, "input #1 read error", 5);
rgb1_bytes = any2rgb(&rgb1_buf, &ri1, iobuf, t_in1);
IMGC_XTEST(!rgb1_bytes, "can not process input file #1", 6);
fclose(fin);
fin = fopen(argv[2], "rb");
ss_read(&iobuf, fin, MAX_FILE_SIZE);
in_size = ss_size(iobuf);
IMGC_XTEST(!in_size, "input #2 read error", 7);
rgb2_bytes = any2rgb(&rgb2_buf, &ri2, iobuf, t_in2);
IMGC_XTEST(!rgb2_bytes, "can not process input file #2", 8);
IMGC_XTEST(ss_size(rgb1_buf) != ss_size(rgb2_buf),
"can not process input file #2", 9);
exit_code = rgbdiff(&rgb3_buf, rgb1_buf, &ri1, rgb2_buf, &ri2)
? 1
: 0;
if (exit_code == 1)
fprintf(stderr, "Image files %s and %s differ\n",
argv[1], argv[2]);
if (t_out != IMG_none) {
enc_bytes =
rgb2type(&iobuf, t_out, rgb3_buf, &ri1, F_None);
IMGC_XTEST(!enc_bytes, "output file encoding error",
10);
fout = fopen(argv[3], "wb+");
written = ss_write(fout, iobuf, 0, ss_size(iobuf));
IMGC_XTEST(!ro
&& (written < 0
|| (size_t)written
!= ss_size(iobuf)),
"write error", 11);
}
break;
}
#ifdef S_USE_VA_ARGS
ss_free(&iobuf, &rgb1_buf, &rgb2_buf, &rgb3_buf);
#else
ss_free(&iobuf);
ss_free(&rgb1_buf);
ss_free(&rgb2_buf);
ss_free(&rgb3_buf);
#endif
if (fin)
fclose(fin);
if (fout)
fclose(fout);
return exit_code > 1 ? exit_with_error(argv, exit_msg, exit_code) : 0;
}
int main(int argc, char* argv[]) {
FILE* F;
MSA *msa;
int *msa_gap_patterns = NULL;
HMM *hmm = NULL;
TreeNode *tree = NULL;
int i, input_format = SS, msa_idx, quiet_mode = FALSE,
ncats, nmsas, ncats_unspooled, indel_nseqs = -1;
String *msa_fname, *gff_fname;
List *gff_fname_list = NULL, *msa_fname_list = NULL,
*msa_length_list = NULL, *model_indels_str = NULL;
Matrix *traincounts = NULL;
Vector *begcounts = NULL, *statecounts = NULL;
CategoryMap *cm = NULL;
char c;
GapPatternMap *gpm = NULL;
GFF_Set *gff;
char *reverse_groups_tag = NULL;
while ((c = getopt(argc, argv, "i:g:c:m:M:R:I:n:t:P:G:qh")) != -1) {
switch(c) {
case 'i':
input_format = msa_str_to_format(optarg);
if (input_format == -1)
die("ERROR: bad alignment format.\n");
break;
case 'g':
gff_fname_list = get_arg_list(optarg);
break;
case 'c':
cm = cm_new_string_or_file(optarg);
break;
case 'm':
msa_fname_list = get_arg_list(optarg);
break;
case 'M':
msa_length_list = str_list_as_int(get_arg_list(optarg));
break;
case 'R':
reverse_groups_tag = optarg;
break;
case 'I':
model_indels_str = get_arg_list(optarg);
break;
case 'n':
indel_nseqs = get_arg_int(optarg);
break;
case 't':
if (optarg[0] == '(') /* in this case, assume topology given
at command line */
tree = tr_new_from_string(optarg);
else
tree = tr_new_from_file(phast_fopen(optarg, "r"));
break;
case 'q':
quiet_mode = TRUE;
break;
case 'h':
print_usage();
exit(0);
case '?':
die("ERROR: unrecognized option.\n\nType 'hmm_train -h' for usage.\n");
}
}
if (msa_fname_list == NULL)
die("ERROR: -m required. Type 'hmm_train -h' for usage.\n");
if (gff_fname_list == NULL)
die("ERROR: -g required in training mode. Type 'hmm_train -h' for usage.\n");
if (msa_length_list != NULL && msa_fname_list != NULL)
die("ERROR: -m and -M are mutually exclusive. Type 'hmm_train -h' for usage.\n");
if (model_indels_str != NULL && tree == NULL)
die("ERROR: -I requires -t. Type 'hmm_train -h' for usage.\n");
if (cm == NULL)
die("ERROR: category map required.\n");
set_seed(-1);
ncats = cm->ncats + 1;
ncats_unspooled = cm->unspooler != NULL ? cm->unspooler->nstates_unspooled :
ncats;
nmsas = (msa_length_list != NULL ? lst_size(msa_length_list) :
lst_size(msa_fname_list));
if (model_indels_str != NULL) {
if (tree == NULL)
die("ERROR: tree is NULL\n"); /*FIXME: indel_ncats broken */
gpm = gp_create_gapcats(cm, model_indels_str, tree, FALSE);
ncats = cm->ncats + 1; /* numbers will change */
ncats_unspooled = cm->unspooler == NULL ? ncats :
cm->unspooler->nstates_unspooled;
}
/* allocate memory for storage of "training paths" */
traincounts = mat_new(ncats_unspooled, ncats_unspooled);
statecounts = vec_new(ncats_unspooled);
begcounts = vec_new(ncats_unspooled);
mat_zero(traincounts);
vec_zero(statecounts);
vec_zero(begcounts);
/* create skeleton of new HMM. */
hmm = hmm_new_nstates(ncats_unspooled, 0, 0);
/* Main loop: consider each MSA in turn */
for (msa_idx = 0; msa_idx < nmsas; msa_idx++) {
if (msa_fname_list != NULL) {
msa_fname = (String*)lst_get_ptr(msa_fname_list, msa_idx);
F = phast_fopen(msa_fname->chars, "r");
if (!quiet_mode)
fprintf(stderr, "Reading alignment from %s ...\n",
F == stdin ? "stdin" : msa_fname->chars);
msa = msa_new_from_file(F, NULL);
phast_fclose(F);
}
else { /* only lengths of alignments specified */
msa = msa_new(NULL, NULL, 0, lst_get_int(msa_length_list, msa_idx), NULL);
/* just a shell in this case */
}
gff_fname = (String*)lst_get_ptr(gff_fname_list, msa_idx);
if (!quiet_mode)
fprintf(stderr, "Reading annotations from %s ...\n", gff_fname->chars);
gff = gff_read_set(phast_fopen(gff_fname->chars, "r"));
/* convert GFF to coordinate frame of alignment */
if (msa_length_list == NULL) {
if (!quiet_mode)
fprintf(stderr, "Mapping annotations to alignment ...\n");
msa_map_gff_coords(msa, gff, 1, 0, 0); /* assume seq 1 is ref */
}
if (model_indels_str != NULL) {
if (!quiet_mode)
fprintf(stderr, "Obtaining gap patterns ...\n");
msa_gap_patterns = smalloc(msa->length * sizeof(int));
gp_set_phylo_patterns(gpm, msa_gap_patterns, msa);
}
/* at this point, we don't actually need the alignment anymore;
if using ordered suff stats (likely with large data sets),
can free them now, to avoid running out of memory */
if (msa->ss != NULL) {
ss_free(msa->ss);
msa->ss = NULL;
}
if (reverse_groups_tag != NULL) {
if (!quiet_mode)
fprintf(stderr, "Reverse complementing features on negative strand (group by '%s') ...\n",
reverse_groups_tag);
/* we don't need to reverse complement the whole alignment --
just the gff and possibly the gap pattern array (pass a
NULL msa) */
gff_group(gff, reverse_groups_tag);
msa_reverse_compl_feats(NULL, gff, msa_gap_patterns);
}
if (!quiet_mode)
fprintf(stderr, "Labeling sites by category ...\n");
msa_label_categories(msa, gff, cm);
gff_free_set(gff);
if (model_indels_str != NULL) {
if (!quiet_mode)
fprintf(stderr, "Remapping categories according to gap patterns ...\n");
if (indel_nseqs > 0 && indel_nseqs != msa->nseqs) {
/* in this case, we'll simply reassign non-trivial gap
patterns randomly. This will achieve the desired
effect with minimal coding, as long as the number of
sites is not too small (the indel model is probably
useless anyway if the number is small) */
int pat, newpat;
int npatterns = 4 * indel_nseqs - 5;
int complex_allowed[cm->ncats+1];
List *no_complex_names, *no_complex_nums;
if (!quiet_mode)
fprintf(stderr, "(target number of sequences: %d)\n", indel_nseqs);
/* set up index indicating by cat no. whether complex gaps
are allowed */
for (i = 0; i < ncats; i++) complex_allowed[i] = 1;
no_complex_names = lst_new_ptr(10);
str_split(str_new_charstr(NO_COMPLEX), ",", no_complex_names);
no_complex_nums = cm_get_category_list(cm, no_complex_names, 1);
for (i = 0; i < lst_size(no_complex_nums); i++)
complex_allowed[lst_get_int(no_complex_nums, i)] = 0;
lst_free(no_complex_nums);
lst_free_strings(no_complex_names);
lst_free(no_complex_names);
/* now reassign all non-null numbers */
for (i = 0; i < msa->length; ) {
if ((pat = msa_gap_patterns[i]) != 0) {
if (complex_allowed[msa->categories[i]])
newpat = 1 + ((double)npatterns * unif_rand());
/* random number in interval [1, npatterns] */
else
newpat = 1 + ((double)(npatterns-1) * unif_rand());
/* random number in interval [1,npatterns-1]
(excludes complex gap pattern) */
for (; i < msa->length && msa_gap_patterns[i] == pat; i++)
msa_gap_patterns[i] = newpat; /* change for whole sequence */
}
else i++;
}
}
/* obtain gapped category number for each site */
for (i = 0; i < msa->length; i++)
if (gpm->cat_x_pattern_to_gapcat[msa->categories[i]] != NULL)
msa->categories[i] = gpm->cat_x_pattern_to_gapcat[msa->categories[i]][msa_gap_patterns[i]];
}
if (!quiet_mode)
fprintf(stderr, "Unspooling categories ...\n");
cm_spooled_to_unspooled(cm, msa->categories, msa->length);
if (!quiet_mode)
fprintf(stderr, "Collecting training data ...\n");
hmm_train_update_counts(traincounts, statecounts, begcounts,
msa->categories, msa->length,
ncats_unspooled);
if (msa_gap_patterns != NULL) sfree(msa_gap_patterns);
msa_free(msa);
}
/* now train HMM, using cumulative data */
hmm_train_from_counts(hmm, traincounts, NULL, statecounts, NULL,
begcounts, NULL);
/* if modeling indels, adjust begin transitions so probability is
distributed among different "gap pattern" states that all
correspond to the same ungapped state (category); this helps
avoid problems that occur when training on a few large sequences
(e.g., whole chromosomes) and then testing on many shorter ones */
if (model_indels_str != NULL) {
double tprob[gpm->ncats];
int nst[gpm->ncats]; /* total prob and number of states per
spooled, ungapped category */
for (i = 0; i < gpm->ncats; i++) tprob[i] = nst[i] = 0;
for (i = 0; i < hmm->nstates; i++) {
if (vec_get(hmm->begin_transitions, i) > 0)
/* have to go from unspooled space to spooled space, then to
ungapped space (HMM states correspond to unspooled,
gapped categories). Note that states with nonzero begin
probs shouldn't be conditioned on other states. */
tprob[gpm->gapcat_to_cat[cm_unspooled_to_spooled_cat(cm, i)]] +=
vec_get(hmm->begin_transitions, i);
nst[gpm->gapcat_to_cat[cm_unspooled_to_spooled_cat(cm, i)]]++;
}
for (i = 0; i < hmm->nstates; i++)
if (tprob[gpm->gapcat_to_cat[cm_unspooled_to_spooled_cat(cm, i)]] > 0)
vec_set(hmm->begin_transitions, i,
tprob[gpm->gapcat_to_cat[cm_unspooled_to_spooled_cat(cm, i)]] /
nst[gpm->gapcat_to_cat[cm_unspooled_to_spooled_cat(cm, i)]]);
/* (uniform prior) */
}
/* write trained HMM */
hmm_print(stdout, hmm);
if (!quiet_mode) fprintf(stderr, "Done.\n");
return 0;
}
S_INLINE void sso_set0(srt_stringo *so, const srt_string *s1,
const srt_string *s2, srt_string *sa, srt_string *sb)
{
size_t s1s, s2s;
srt_string *so1, *so2;
if (!so)
return;
if (!s1)
s1 = ss_void;
if (!s2)
s2 = ss_void;
s1s = ss_size(s1);
s2s = ss_size(s2);
if (s1s + s2s <= OptStr_MaxSize_DD) {
so1 = (srt_string *)so->kv.di.s_raw;
ss_alloc_into_ext_buf(so1, OptStr_MaxSize_DI);
ss_cpy(&so1, s1);
so->t = OptStr_DD;
so2 = (srt_string *)sso_get_s2(so);
ss_alloc_into_ext_buf(so2, OptStr_MaxSize_DI - s1s);
ss_cpy(&so2, s2);
} else if (s1s <= OptStr_MaxSize_DI) {
so1 = (srt_string *)so->kv.di.s_raw;
ss_alloc_into_ext_buf(so1, OptStr_MaxSize_DI);
ss_cpy(&so1, s1);
if (sa || sb) {
if (sa) {
so->kv.di.si = sa;
sa = NULL;
} else {
so->kv.di.si = sb;
sb = NULL;
}
ss_cpy(&so->kv.di.si, s2);
} else
so->kv.di.si = ss_dup(s2);
so->t = OptStr_DI;
} else if (s2s <= OptStr_MaxSize_DI) {
if (sa || sb) {
if (sa) {
so->kv.di.si = sa;
sa = NULL;
} else {
so->kv.di.si = sb;
sb = NULL;
}
ss_cpy(&so->kv.di.si, s1);
} else
so->kv.di.si = ss_dup(s1);
so2 = (srt_string *)so->kv.di.s_raw;
ss_alloc_into_ext_buf(so2, OptStr_MaxSize_DI);
ss_cpy(&so2, s2);
so->t = OptStr_ID;
} else {
if (sa) {
so->kv.ii.s1 = sa;
sa = NULL;
ss_cpy(&so->kv.ii.s1, s1);
} else
so->kv.ii.s1 = ss_dup(s1);
if (sb) {
so->kv.ii.s2 = sb;
sb = NULL;
ss_cpy(&so->kv.ii.s2, s2);
} else
so->kv.ii.s2 = ss_dup(s2);
so->t = OptStr_II;
}
ss_free(&sa);
ss_free(&sb);
}
int sr_conf_write(srconf *m, srconfstmt *s)
{
if (m->flags & SR_RO) {
sr_error(s->r->e, "%s is read-only", s->path);
return -1;
}
switch (m->type) {
case SS_U32:
if (s->valuetype == SS_I64) {
sscastu32(m->value) = sscasti64(s->value);
} else
if (s->valuetype == SS_U32) {
sscastu32(m->value) = sscastu32(s->value);
} else
if (s->valuetype == SS_U64) {
sscastu32(m->value) = sscastu64(s->value);
} else {
goto bad_type;
}
break;
case SS_U64:
if (s->valuetype == SS_I64) {
sscastu64(m->value) = sscasti64(s->value);
} else
if (s->valuetype == SS_U32) {
sscastu64(m->value) = sscastu32(s->value);
} else
if (s->valuetype == SS_U64) {
sscastu64(m->value) = sscastu64(s->value);
} else {
goto bad_type;
}
break;
case SS_STRINGPTR: {
char **string = m->value;
if (s->valuetype == SS_STRING) {
char *sz = s->value;
if (s->valuesize > 0) {
sz = ss_malloc(s->r->a, s->valuesize);
if (ssunlikely(sz == NULL))
return sr_oom(s->r->e);
memcpy(sz, s->value, s->valuesize);
}
if (*string)
ss_free(s->r->a, *string);
*string = sz;
} else {
goto bad_type;
}
break;
}
default:
assert(0);
return -1;
}
return 0;
bad_type:
return sr_error(s->r->e, "configuration write bad type (%s) for (%s) %s",
ss_typeof(s->valuetype),
ss_typeof(m->type), s->path);
}
jconf_t *
read_jconf(const char *file)
{
static jconf_t conf;
memset(&conf, 0, sizeof(jconf_t));
char *buf;
json_value *obj;
FILE *f = fopen(file, "rb");
if (f == NULL) {
FATAL("Invalid config path.");
}
fseek(f, 0, SEEK_END);
long pos = ftell(f);
fseek(f, 0, SEEK_SET);
if (pos >= MAX_CONF_SIZE) {
FATAL("Too large config file.");
}
buf = ss_malloc(pos + 1);
if (buf == NULL) {
FATAL("No enough memory.");
}
int nread = fread(buf, pos, 1, f);
if (!nread) {
FATAL("Failed to read the config file.");
}
fclose(f);
buf[pos] = '\0'; // end of string
json_settings settings = { 0UL, 0, NULL, NULL, NULL };
char error_buf[512];
obj = json_parse_ex(&settings, buf, pos, error_buf);
if (obj == NULL) {
FATAL(error_buf);
}
if (obj->type == json_object) {
unsigned int i, j;
for (i = 0; i < obj->u.object.length; i++) {
char *name = obj->u.object.values[i].name;
json_value *value = obj->u.object.values[i].value;
if (strcmp(name, "server") == 0) {
if (value->type == json_array) {
for (j = 0; j < value->u.array.length; j++) {
if (j >= MAX_REMOTE_NUM) {
break;
}
json_value *v = value->u.array.values[j];
char *addr_str = to_string(v);
parse_addr(addr_str, conf.remote_addr + j);
ss_free(addr_str);
conf.remote_num = j + 1;
}
} else if (value->type == json_string) {
conf.remote_addr[0].host = to_string(value);
conf.remote_addr[0].port = NULL;
conf.remote_num = 1;
}
} else if (strcmp(name, "server_port") == 0) {
conf.remote_port = to_string(value);
} else if (strcmp(name, "local_address") == 0) {
conf.local_addr = to_string(value);
} else if (strcmp(name, "local_port") == 0) {
conf.local_port = to_string(value);
} else if (strcmp(name, "timeout") == 0) {
conf.timeout = to_string(value);
} else if (strcmp(name, "user") == 0) {
conf.user = to_string(value);
} else if (strcmp(name, "obfs") == 0) {
conf.obfs = to_string(value);
} else if (strcmp(name, "obfs_host") == 0) {
conf.obfs_host = to_string(value);
} else if (strcmp(name, "obfs_uri") == 0) {
conf.obfs_uri = to_string(value);
} else if (strcmp(name, "http_method") == 0) {
conf.http_method = to_string(value);
} else if (strcmp(name, "failover") == 0) {
conf.failover = to_string(value);
} else if (strcmp(name, "fast_open") == 0) {
check_json_value_type(value, json_boolean,
"invalid config file: option 'fast_open' must be a boolean");
conf.fast_open = value->u.boolean;
} else if (strcmp(name, "nofile") == 0) {
check_json_value_type(value, json_integer,
"invalid config file: option 'nofile' must be an integer");
conf.nofile = value->u.integer;
} else if (strcmp(name, "nameserver") == 0) {
conf.nameserver = to_string(value);
} else if (strcmp(name, "dst_addr") == 0) {
conf.dst_addr = to_string(value);
} else if (strcmp(name, "mptcp") == 0) {
check_json_value_type(value, json_boolean,
"invalid config file: option 'mptcp' must be a boolean");
conf.mptcp = value->u.boolean;
} else if (strcmp(name, "ipv6_first") == 0) {
check_json_value_type(value, json_boolean,
"invalid config file: option 'ipv6_first' must be a boolean");
conf.ipv6_first = value->u.boolean;
} else if (strcmp(name, "reverse_proxy") == 0) {
check_json_value_type(value, json_boolean,
"invalid config file: option 'reverse_proxy' must be a boolean");
conf.reverse_proxy = value->u.boolean;
}
}
} else {
FATAL("Invalid config file");
}
ss_free(buf);
json_value_free(obj);
return &conf;
}
int main(int argc, char *argv[]) {
char c;
List *l;
int i, j, strand, bed_output = 0, backgd_nmods = -1, feat_nmods = -1,
winsize = -1, verbose = 0, max_nmods, memblocksize, old_nleaves,
refidx = 1, base_by_base = FALSE, windowWig = FALSE;
TreeModel **backgd_mods = NULL, **feat_mods = NULL;
HMM *backgd_hmm = NULL, *feat_hmm = NULL;
msa_format_type inform = UNKNOWN_FORMAT;
GFF_Set *features = NULL;
MSA *msa, *msa_compl=NULL;
double **backgd_emissions, **feat_emissions, **mem, **dummy_emissions,
*winscore_pos=NULL, *winscore_neg=NULL;
int *no_alignment=NULL;
List *pruned_names;
char *msa_fname;
FILE *infile;
int opt_idx;
struct option long_opts[] = {
{"background-mods", 1, 0, 'b'},
{"background-hmm", 1, 0, 'B'},
{"feature-mods", 1, 0, 'f'},
{"feature-hmm", 1, 0, 'F'},
{"features", 1, 0, 'g'},
{"window", 1, 0, 'w'},
{"window-wig", 1, 0, 'W'},
{"base-by-base", 0, 0, 'y'},
{"msa-format", 1, 0, 'i'},
{"refidx", 1, 0, 'r'},
{"output-bed", 0, 0, 'd'},
{"verbose", 0, 0, 'v'},
{"help", 0, 0, 'h'},
{0, 0, 0, 0}
};
while ((c = getopt_long(argc, argv, "B:b:F:f:r:g:w:W:i:ydvh", long_opts, &opt_idx)) != -1) {
switch (c) {
case 'B':
backgd_hmm = hmm_new_from_file(phast_fopen(optarg, "r"));
break;
case 'b':
l = get_arg_list(optarg);
backgd_nmods = lst_size(l);
backgd_mods = smalloc(backgd_nmods * sizeof(void*));
for (i = 0; i < backgd_nmods; i++)
backgd_mods[i] = tm_new_from_file(phast_fopen(((String*)lst_get_ptr(l, i))->chars, "r"), 1);
lst_free_strings(l);
lst_free(l);
break;
case 'F':
feat_hmm = hmm_new_from_file(phast_fopen(optarg, "r"));
break;
case 'f':
l = get_arg_list(optarg);
feat_nmods = lst_size(l);
feat_mods = smalloc(feat_nmods * sizeof(void*));
for (i = 0; i < feat_nmods; i++)
feat_mods[i] = tm_new_from_file(phast_fopen(((String*)lst_get_ptr(l, i))->chars, "r"), 1);
lst_free_strings(l);
lst_free(l);
break;
case 'g':
features = gff_read_set(phast_fopen(optarg, "r"));
break;
case 'w':
winsize = get_arg_int(optarg);
if (winsize <= 0) die("ERROR: window size must be positive.\n");
break;
case 'W':
winsize = get_arg_int(optarg);
if (winsize <= 0) die("ERROR: window size must be positive.\n");
windowWig = TRUE;
break;
case 'y':
base_by_base = TRUE;
break;
case 'i':
inform = msa_str_to_format(optarg);
if (inform == UNKNOWN_FORMAT) die("Bad argument to -i.\n");
break;
case 'r':
refidx = get_arg_int_bounds(optarg, 0, INFTY);
break;
case 'd':
bed_output = 1;
break;
case 'h':
printf("%s", HELP);
exit(0);
case 'v':
verbose = 1;
break;
case '?':
die("Bad argument. Try '%s -h'.\n", argv[0]);
}
}
set_seed(-1);
if (backgd_mods == NULL || feat_mods == NULL)
die("ERROR: -b and -f required. Try '%s -h'.\n", argv[0]);
if (backgd_nmods == 1 && backgd_hmm == NULL)
backgd_hmm = hmm_create_trivial();
else if (backgd_hmm == NULL)
die("ERROR: -B required. Try '%s -h'.\n", argv[0]);
if (feat_nmods == 1 && feat_hmm == NULL)
feat_hmm = hmm_create_trivial();
else if (feat_hmm == NULL)
die("ERROR: -F required. Try '%s -h'.\n", argv[0]);
if ((winsize == -1 && features == NULL && !base_by_base) ||
(winsize != -1 && features != NULL) ||
(winsize != -1 && base_by_base) ||
(features != NULL && base_by_base))
die("ERROR: must specify exactly one of -g, -w, and -y. Try '%s -h'.\n", argv[0]);
if (backgd_hmm->nstates != backgd_nmods)
die("ERROR: number of states must equal number of tree models for background.\n");
if (feat_hmm->nstates != feat_nmods)
die("ERROR: number of states must equal number of tree models for features.\n");
if (features != NULL && lst_size(features->features) == 0)
die("ERROR: empty features file.\n");
if (base_by_base && (backgd_nmods > 1 || feat_nmods > 1))
die("ERROR: only single phylogenetic models (not HMMs) are supported with --base-by-base.\n");
if (optind != argc - 1)
die("ERROR: too few arguments. Try '%s -h'.\n", argv[0]);
if (verbose) fprintf(stderr, "Reading alignment ...\n");
msa_fname = argv[optind];
infile = phast_fopen(msa_fname, "r");
if (inform == UNKNOWN_FORMAT)
inform = msa_format_for_content(infile, 1);
if (inform == MAF)
msa = maf_read(infile, NULL, 1, NULL, NULL,
NULL, -1, TRUE, NULL, NO_STRIP, FALSE);
else
msa = msa_new_from_file_define_format(infile, inform, NULL);
if (msa_alph_has_lowercase(msa)) msa_toupper(msa);
msa_remove_N_from_alph(msa);
/* need ordered representation of alignment */
if (msa->seqs == NULL && (msa->ss == NULL || msa->ss->tuple_idx == NULL) )
die("ERROR: ordered sufficient statistics are required.\n");
pruned_names = lst_new_ptr(msa->nseqs);
for (i = 0; i < backgd_nmods; i++) {
old_nleaves = (backgd_mods[i]->tree->nnodes + 1) / 2;
tm_prune(backgd_mods[i], msa, pruned_names);
if (lst_size(pruned_names) >= old_nleaves)
die("ERROR: no match for leaves of tree in alignment (background model #%d)\n", i+1);
else if (lst_size(pruned_names) > 0) {
fprintf(stderr, "WARNING: pruned away leaves in background model (#%d) with no match in alignment (", i+1);
for (j = 0; j < lst_size(pruned_names); j++)
fprintf(stderr, "%s%s", ((String*)lst_get_ptr(pruned_names, j))->chars,
j < lst_size(pruned_names) - 1 ? ", " : ").\n");
}
lst_free_strings(pruned_names);
}
for (i = 0; i < feat_nmods; i++) {
old_nleaves = (feat_mods[i]->tree->nnodes + 1) / 2;
tm_prune(feat_mods[i], msa, pruned_names);
if (lst_size(pruned_names) >= old_nleaves)
die("ERROR: no match for leaves of tree in alignment (features model #%d)\n", i+1);
else if (lst_size(pruned_names) > 0) {
fprintf(stderr, "WARNING: pruned away leaves in features model (#%d) with no match in alignment (", i+1);
for (j = 0; j < lst_size(pruned_names); j++)
fprintf(stderr, "%s%s", ((String*)lst_get_ptr(pruned_names, j))->chars,
j < lst_size(pruned_names) - 1 ? ", " : ").\n");
}
lst_free_strings(pruned_names);
}
lst_free(pruned_names);
/* first have to subtract offset from features, if necessary */
if (msa->idx_offset != 0 && features != NULL) {
for (i = 0; i < lst_size(features->features); i++) {
GFF_Feature *f = lst_get_ptr(features->features, i);
f->start -= msa->idx_offset;
f->end -= msa->idx_offset;
}
}
/* convert to coord frame of alignment */
if (features != NULL && refidx != 0) {
if (verbose) fprintf(stderr, "Mapping coordinates ...\n");
msa_map_gff_coords(msa, features, refidx, 0, 0);
if (lst_size(features->features) == 0)
die("ERROR: no features within coordinate range of alignment.\n");
}
/* Make a reverse complemented copy of the alignment. The two
strands will be processed separately, to avoid problems with
overlapping features, etc. */
if (!base_by_base) { /* skip in base by base case */
if (verbose) fprintf(stderr, "Creating reverse complemented alignment ...\n");
msa_compl = msa_create_copy(msa, 0);
/* temporary workaround: make sure reverse complement not based on
sufficient stats */
if (msa_compl->seqs == NULL) ss_to_msa(msa_compl);
if (msa_compl->ss != NULL) {
ss_free(msa_compl->ss);
msa_compl->ss = NULL;
}
msa_reverse_compl(msa_compl);
}
/* allocate memory for computing scores */
backgd_emissions = smalloc(backgd_nmods * sizeof(void*));
for (i = 0; i < backgd_nmods; i++)
backgd_emissions[i] = smalloc(msa->length * sizeof(double));
feat_emissions = smalloc(feat_nmods * sizeof(void*));
for (i = 0; i < feat_nmods; i++)
feat_emissions[i] = smalloc(msa->length * sizeof(double));
max_nmods = max(backgd_nmods, feat_nmods);
dummy_emissions = smalloc(max_nmods * sizeof(void*));
mem = smalloc(max_nmods * sizeof(void*));
/* memory for forward algorithm -- each block must be as large as
the largest feature */
if (features != NULL) {
for (i = 0, memblocksize = -1; i < lst_size(features->features); i++) {
GFF_Feature *f = lst_get_ptr(features->features, i);
if (f->end - f->start + 1 > memblocksize)
memblocksize = f->end - f->start + 1;
}
}
else memblocksize = winsize; /* -1 if base-by-base mode */
if (memblocksize > 0)
for (i = 0; i < max_nmods; i++)
mem[i] = smalloc(memblocksize * sizeof(double));
if (winsize != -1) {
winscore_pos = smalloc(msa->length * sizeof(double));
winscore_neg = smalloc(msa->length * sizeof(double));
no_alignment = smalloc(msa->length * sizeof(int));
for (i = 0; i < msa->length; i++) {
winscore_pos[i] = winscore_neg[i] = NEGINFTY;
if (refidx == 0)
no_alignment[i] = FALSE;
else
no_alignment[i] = msa_missing_col(msa, refidx, i);
}
}
/* the rest will be repeated for each strand */
for (strand = 1; strand <= 2; strand++) {
MSA *thismsa = strand == 1 ? msa : msa_compl;
double *winscore = strand == 1 ? winscore_pos : winscore_neg;
if (base_by_base && strand == 2) break; /* don't do second pass in
base_by_base case */
if (verbose) fprintf(stderr, "Processing %c strand ...\n",
strand == 1 ? '+' : '-');
/* set up dummy categories array, so that emissions are only
computed where needed */
thismsa->categories = smalloc(thismsa->length * sizeof(int));
thismsa->ncats = 1;
if (winsize != -1) {
if (strand == 1)
for (i = 0; i < thismsa->length; i++)
thismsa->categories[i] = no_alignment[i] ? 0 : 1;
else
for (i = 0; i < thismsa->length; i++)
thismsa->categories[i] = no_alignment[thismsa->length - i - 1] ? 0 : 1;
}
else if (features != NULL) {
for (i = 0; i < thismsa->length; i++) thismsa->categories[i] = 0;
for (i = 0; i < lst_size(features->features); i++) {
GFF_Feature *f = lst_get_ptr(features->features, i);
if (f->start <= 0 || f->end <= 0) {
fprintf(stderr, "WARNING: feature out of range ('");
gff_print_feat(stderr, f);
fprintf(stderr, "')\n");
continue;
}
if (strand == 1 && f->strand != '-')
for (j = f->start - 1; j < f->end; j++)
thismsa->categories[j] = 1;
else if (strand == 2 && f->strand == '-')
for (j = thismsa->length - f->end;
j < thismsa->length - f->start + 1; j++)
thismsa->categories[j] = 1;
}
}
else { /* base-by-base scores */
for (i = 0; i < thismsa->length; i++) thismsa->categories[i] = 1;
}
if (thismsa->ss != NULL) ss_update_categories(thismsa);
/* compute emissions */
for (i = 0; i < backgd_nmods; i++) {
if (verbose)
fprintf(stderr, "Computing emissions for background model #%d ...\n", i+1);
tl_compute_log_likelihood(backgd_mods[i], thismsa,
backgd_emissions[i], NULL, 1, NULL);
}
for (i = 0; i < feat_nmods; i++) {
if (verbose)
fprintf(stderr, "Computing emissions for features model #%d ...\n", i+1);
tl_compute_log_likelihood(feat_mods[i], thismsa,
feat_emissions[i], NULL, 1, NULL);
}
/* now compute scores */
if (winsize != -1) { /* windows case */
int winstart;
if (verbose) fprintf(stderr, "Computing scores ...\n");
for (winstart = 0; winstart <= thismsa->length - winsize; winstart++) {
int centeridx = winstart + winsize/2;
if (strand == 2) centeridx = thismsa->length - centeridx - 1;
if (no_alignment[centeridx]) continue;
for (j = 0; j < feat_nmods; j++)
dummy_emissions[j] = &(feat_emissions[j][winstart]);
winscore[centeridx] = hmm_forward(feat_hmm, dummy_emissions,
winsize, mem);
if (winscore[centeridx] <= NEGINFTY) {
winscore[centeridx] = NEGINFTY;
continue;
}
for (j = 0; j < backgd_nmods; j++)
dummy_emissions[j] = &(backgd_emissions[j][winstart]);
winscore[centeridx] -= hmm_forward(backgd_hmm, dummy_emissions,
winsize, mem);
if (winscore[centeridx] < NEGINFTY) winscore[centeridx] = NEGINFTY;
}
}
else if (features != NULL) { /* features case */
if (verbose) fprintf(stderr, "Computing scores ...\n");
for (i = 0; i < lst_size(features->features); i++) {
GFF_Feature *f = lst_get_ptr(features->features, i);
int s, e;
if ((strand == 1 && f->strand == '-') ||
(strand == 2 && f->strand != '-') ||
f->start <= 0 || f->end <= 0 || f->end - f->start < 0)
continue;
/* effective coords */
if (f->strand == '-') {
s = thismsa->length - f->end + 1;
e = thismsa->length - f->start + 1;
}
else {
s = f->start;
e = f->end;
}
f->score_is_null = 0;
for (j = 0; j < feat_nmods; j++)
dummy_emissions[j] = &(feat_emissions[j][s-1]);
f->score = hmm_forward(feat_hmm, dummy_emissions, e - s + 1, mem);
if (f->score <= NEGINFTY) {
f->score = NEGINFTY;
continue;
}
for (j = 0; j < backgd_nmods; j++)
dummy_emissions[j] = &(backgd_emissions[j][s-1]);
f->score -= hmm_forward(backgd_hmm, dummy_emissions, e - s + 1, mem);
if (f->score < NEGINFTY) f->score = NEGINFTY;
}
}
}
if (verbose) fprintf(stderr, "Generating output ...\n");
if (winsize != -1 && windowWig == FALSE) { /* standard windows output */
for (i = 0, j = 0; i < msa->length; i++) {
if (no_alignment[i] == FALSE)
printf("%d\t%.3f\t%.3f\n", j + msa->idx_offset + 1, winscore_pos[i],
winscore_neg[i]);
if (ss_get_char_pos(msa, i, 0, 0) != GAP_CHAR) j++;
}
}
else if (windowWig == TRUE) { /* windows with wig output */
int last = NEGINFTY;
for (i = 0, j = 0; i < msa->length; i++) {
if (refidx == 0 || msa_get_char(msa, refidx-1, i) != GAP_CHAR) {
if (no_alignment[i] == FALSE && winscore_pos[i] > NEGINFTY) {
if (j > last + 1)
printf("fixedStep chrom=%s start=%d step=1\n",
refidx > 0 ? msa->names[refidx-1] : "alignment",
j + msa->idx_offset + 1);
printf("%.3f\n", winscore_pos[i]);
last = j;
}
j++;
}
}
}
else if (features != NULL) { /* features output */
/* return to coord frame of reference seq (also, replace offset) */
if (refidx != 0)
msa_map_gff_coords(msa, features, 0, refidx, msa->idx_offset);
else if (msa->idx_offset != 0) {
for (i = 0; i < lst_size(features->features); i++) {
GFF_Feature *f = lst_get_ptr(features->features, i);
f->start += msa->idx_offset;
f->end += msa->idx_offset;
}
}
if (bed_output)
gff_print_bed(stdout, features, FALSE);
else
gff_print_set(stdout, features);
}
else { /* base-by-base scores */
/* in this case, we can just output the difference between the emissions */
printf("fixedStep chrom=%s start=%d step=1\n",
refidx > 0 ? msa->names[refidx-1] : "alignment",
msa->idx_offset + 1);
for (i = 0, j = 0; i < msa->length; i++) {
if (refidx == 0 || msa_get_char(msa, refidx-1, i) != GAP_CHAR) {
printf("%.3f\n", feat_emissions[0][i] - backgd_emissions[0][i]);
j++;
}
}
}
if (verbose) fprintf(stderr, "\nDone.\n");
return 0;
}
int main(int argc, const char **argv)
{
size_t in_size = 0, enc_bytes, rgb_bytes;
ssize_t written;
struct RGB_Info ri;
srt_string *iobuf = NULL, *rgb_buf = NULL;
int exit_code = 1;
FILE *fin = NULL, *fout = NULL;
const char *exit_msg = "not enough parameters";
int filter = F_None;
enum ImgTypes t_in, t_out;
srt_bool ro;
#define IMGC_XTEST(test, m, c) \
if (test) { \
exit_msg = m; \
exit_code = c; \
break; \
}
for (;;) {
if (argc < 2)
break;
if (argc > 3) {
filter = atoi(argv[3]);
IMGC_XTEST(filter >= F_NumElems, "invalid filter", 10);
}
ro = argc < 3 ? S_TRUE : S_FALSE;
t_in = file_type(argv[1]);
t_out = ro ? IMG_none : file_type(argv[2]);
IMGC_XTEST(t_in == IMG_error || t_out == IMG_error,
"invalid parameters", t_in == IMG_error ? 2 : 3);
fin = fopen(argv[1], "rb");
iobuf = ss_dup_read(fin, MAX_FILE_SIZE);
in_size = ss_size(iobuf);
IMGC_XTEST(!in_size, "input read error", 4);
rgb_bytes = any2rgb(&rgb_buf, &ri, iobuf, t_in);
IMGC_XTEST(!rgb_bytes, "can not process input file", 5);
if (ro)
printf("%s: ", argv[1]);
enc_bytes = rgb2type(&iobuf, t_out, rgb_buf, &ri, filter);
IMGC_XTEST(!enc_bytes, "output file encoding error", 6);
fout = fopen(argv[2], "wb+");
written = ro ? 0 : ss_write(fout, iobuf, 0, ss_size(iobuf));
IMGC_XTEST(!ro
&& (written < 0
|| (size_t)written != ss_size(iobuf)),
"write error", 7);
exit_code = 0;
if (!ro)
IF_DEBUG_IMGC(fprintf(
stderr,
"%s (%ix%i %ibpp %ich) %u bytes"
" > %s %u bytes\n",
argv[1], (int)ri.width, (int)ri.height,
(int)ri.bpp, (int)ri.chn, (unsigned)in_size,
argv[2], (unsigned)ss_size(iobuf)));
break;
}
#ifdef S_USE_VA_ARGS
ss_free(&iobuf, &rgb_buf);
#else
ss_free(&iobuf);
ss_free(&rgb_buf);
#endif
if (fin)
fclose(fin);
if (fout)
fclose(fout);
return exit_code ? exit_with_error(argv, exit_msg, exit_code) : 0;
}
jconf_t *read_jconf(const char *file)
{
static jconf_t conf;
char *buf;
json_value *obj;
FILE *f = fopen(file, "rb");
if (f == NULL) {
FATAL("Invalid config path.");
}
fseek(f, 0, SEEK_END);
long pos = ftell(f);
fseek(f, 0, SEEK_SET);
if (pos >= MAX_CONF_SIZE) {
FATAL("Too large config file.");
}
buf = ss_malloc(pos + 1);
if (buf == NULL) {
FATAL("No enough memory.");
}
int nread = fread(buf, pos, 1, f);
if (!nread) {
FATAL("Failed to read the config file.");
}
fclose(f);
buf[pos] = '\0'; // end of string
json_settings settings = { 0UL, 0, NULL, NULL, NULL };
char error_buf[512];
obj = json_parse_ex(&settings, buf, pos, error_buf);
if (obj == NULL) {
FATAL(error_buf);
}
if (obj->type == json_object) {
unsigned int i, j;
for (i = 0; i < obj->u.object.length; i++) {
char *name = obj->u.object.values[i].name;
json_value *value = obj->u.object.values[i].value;
if (strcmp(name, "server") == 0) {
if (value->type == json_array) {
for (j = 0; j < value->u.array.length; j++) {
if (j >= MAX_REMOTE_NUM) {
break;
}
json_value *v = value->u.array.values[j];
parse_addr(to_string(v), conf.remote_addr + j);
conf.remote_num = j + 1;
}
} else if (value->type == json_string) {
conf.remote_addr[0].host = to_string(value);
conf.remote_addr[0].port = NULL;
conf.remote_num = 1;
}
} else if (strcmp(name, "port_password") == 0) {
if (value->type == json_object) {
for (j = 0; j < value->u.object.length; j++) {
if (j >= MAX_PORT_NUM) {
break;
}
json_value *v = value->u.object.values[j].value;
if (v->type == json_string) {
conf.port_password[j].port = ss_strndup(value->u.object.values[j].name,
value->u.object.values[j].name_length);
conf.port_password[j].password = to_string(v);
conf.port_password_num = j + 1;
}
}
}
} else if (strcmp(name, "server_port") == 0) {
conf.remote_port = to_string(value);
} else if (strcmp(name, "local_address") == 0) {
conf.local_addr = to_string(value);
} else if (strcmp(name, "local_port") == 0) {
conf.local_port = to_string(value);
} else if (strcmp(name, "password") == 0) {
conf.password = to_string(value);
} else if (strcmp(name, "method") == 0) {
conf.method = to_string(value);
} else if (strcmp(name, "timeout") == 0) {
conf.timeout = to_string(value);
} else if (strcmp(name, "fast_open") == 0) {
conf.fast_open = value->u.boolean;
} else if (strcmp(name, "auth") == 0) {
conf.auth = value->u.boolean;
} else if (strcmp(name, "nofile") == 0) {
conf.nofile = value->u.integer;
} else if (strcmp(name, "nameserver") == 0) {
conf.nameserver = to_string(value);
}
}
} else {
FATAL("Invalid config file");
}
ss_free(buf);
json_value_free(obj);
return &conf;
}
static ss_t *aux_replace(ss_t **s, const sbool_t cat, const ss_t *src,
const size_t off, const ss_t *s1, const ss_t *s2)
{
ASSERT_RETURN_IF(!s, ss_void);
if (!s1)
s1 = ss_void;
if (!s2)
s2 = ss_void;
if (!src)
src = ss_void;
const size_t at = (cat && *s) ? sd_get_size(*s) : 0;
const char *p0 = get_str_r(src),
*p2 = get_str_r(s2);
const size_t l1 = sd_get_size(s1), l2 = sd_get_size(s2);
size_t i = off, l = sd_get_size(src);
ss_t *out = NULL;
ssize_t size_delta = l2 > l1 ? (ssize_t)(l2 - l1) :
-(ssize_t)(l1 - l2);
sbool_t aliasing = S_FALSE;
size_t out_size = at + l;
char *o, *o0;
if (l2 >= l1) { /* resize required */
size_t nfound = 0;
/* scan required size */
for (;; i+= l1, nfound++)
if ((i = ss_find(src, i, s1)) == S_NPOS)
break;
if (nfound == 0) /* 0 occurrences: return */
return ss_check(s);
if (size_delta >= 0)
out_size += (size_t)size_delta * nfound;
else
out_size -= (size_t)(-size_delta) * nfound;
/* allocate output string */
out = ss_alloc(out_size);
if (!out) {
S_ERROR("not enough memory");
sd_set_alloc_errors(*s);
return ss_check(s);
}
o0 = o = get_str(out);
/* copy prefix data (cat) */
if (at > 0)
memcpy(o, get_str_r(*s), at);
} else {
if (s && *s && *s == src) {
aliasing = S_TRUE;
} else {
if (ss_reserve(s, out_size) < out_size) /* BEHAVIOR */
return ss_check(s);
}
o0 = o = get_str(*s);
}
typedef void (*memcpy_t)(void *, const void *, size_t);
memcpy_t f_cpy;
if (aliasing) {
f_cpy = (memcpy_t)memmove;
} else {
f_cpy = (memcpy_t)memcpy;
o += at;
if (off > 0) /* copy not affected data */
memcpy(o, p0, off);
}
o += off;
size_t i_next = s1 == s2? S_NPOS : /* no replace */
ss_find(src, i + off, s1);
for (i = off;;) {
/* before match copy: */
if (i_next == S_NPOS) {
f_cpy(o, p0 + i, l - i);
o += (l - i);
break;
}
f_cpy(o, p0 + i, i_next - i);
o += (i_next - i);
/* replace: */
f_cpy(o, p2, l2);
o += l2;
i = i_next + l1;
/* prepare next search: */
i_next = ss_find(src, i, s1);
}
if (out) {
ss_t *s_bck = *s;
*s = out;
ss_free(&s_bck);
}
set_size(*s, (size_t)(o - o0));
return *s;
}
static ss_t *aux_toXcase(ss_t **s, const sbool_t cat, const ss_t *src,
sint32_t (*towX)(sint32_t))
{
ASSERT_RETURN_IF(!s, ss_void);
if (!src)
src = ss_void;
const size_t ss = sd_get_size(src),
sso_max = *s ? ss_get_max_size(*s) : 0;
const char *ps = get_str_r(src);
ss_t *out = NULL;
const sbool_t aliasing = *s == src;
unsigned char is_cached_usize = 0;
ssize_t extra = sc_utf8_calc_case_extra_size(ps, 0, ss, towX);
size_t cached_usize = 0,
at;
/* If possible, keep Unicode size cached: */
if (*s) {
if (is_unicode_size_cached(*s) && is_unicode_size_cached(src)) {
is_cached_usize = 1;
cached_usize = get_unicode_size(src) +
get_unicode_size(*s);
}
at = cat ? sd_get_size(*s) : 0;
} else { /* copy */
if (is_unicode_size_cached(src)) {
is_cached_usize = 1;
cached_usize = get_unicode_size(src);
}
at = 0;
}
/* Check if it is necessary to allocate more memory: */
size_t sso_req = extra < 0 ? (at + ss - (size_t)(-extra)) :
(at + ss + (size_t)extra);
char *po0;
if (!*s || sso_req > sso_max || (aliasing && extra > 0)) {
if (*s && (*s)->ext_buffer) { /* BEHAVIOR */
S_ERROR("not enough memory: strings stored in the "
"stored in fixed-length buffer can not be "
"resized.");
sd_set_alloc_errors(*s);
return ss_check(s);
}
out = ss_alloc(sso_req);
if (!out) { /* BEHAVIOR */
S_ERROR("not enough memory: can not "
"change character case");
if (*s)
sd_set_alloc_errors(*s);
return ss_check(s);
}
char *pout = get_str(out);
if (at > 0) /* cat */
memcpy(pout, get_str(*s), at);
po0 = pout + at;
} else {
po0 = get_str(*s) + at;
}
/* Case conversion loop: */
size_t i = 0;
int c = 0;
char *po = po0,
u8[SSU8_MAX_SIZE];
for (; i < ss;) {
#ifdef S_ENABLE_UTF8_7BIT_PARALLEL_CASE_OPTIMIZATIONS
unsigned *pou = (unsigned *)po;
const size_t i2 = sc_parallel_toX(ps, i, ss, pou, towX);
if (i != i2) {
po += (i2 - i);
i = i2;
if (i >= ss)
break;
}
#endif
const size_t csize = ss_utf8_to_wc(ps, i, ss, &c, *s);
const int c2 = towX(c);
size_t csize2;
if (c2 == c) {
csize2 = csize;
if (!aliasing)
memcpy(po, ps + i, csize2);
} else {
csize2 = sc_wc_to_utf8(c2, u8, 0, SSU8_MAX_SIZE);
memcpy(po, u8, csize2);
}
i += csize;
po += csize2;
}
if (out) { /* Case of using a secondary string was required */
ss_t *s_bck = *s;
*s = out;
ss_free(&s_bck);
}
if (*s) {
set_size(*s, sso_req);
set_unicode_size_cached(*s, is_cached_usize);
set_unicode_size(*s, cached_usize);
}
return ss_check(s);
}
static void remote_recv_cb(EV_P_ ev_io *w, int revents)
{
ssize_t r;
remote_ctx_t *remote_ctx = (remote_ctx_t *)w;
server_ctx_t *server_ctx = remote_ctx->server_ctx;
// server has been closed
if (server_ctx == NULL) {
LOGE("[udp] invalid server");
close_and_free_remote(EV_A_ remote_ctx);
return;
}
struct sockaddr_storage src_addr;
socklen_t src_addr_len = sizeof(src_addr);
memset(&src_addr, 0, src_addr_len);
buffer_t *buf = ss_malloc(sizeof(buffer_t));
balloc(buf, buf_size1);
// recv
r = recvfrom(remote_ctx->fd, buf->array, buf_size1, 0, (struct sockaddr *)&src_addr, &src_addr_len);
if (r == -1) {
// error on recv
// simply drop that packet
ERROR("[udp] remote_recv_recvfrom");
goto CLEAN_UP;
} else if (r > packet_size) {
LOGE("[udp] remote_recv_recvfrom fragmentation");
goto CLEAN_UP;
}
buf->len = r;
#ifdef MODULE_LOCAL
int err = ss_decrypt_all(buf, server_ctx->method, 0, buf_size1);
if (err) {
// drop the packet silently
goto CLEAN_UP;
}
#ifdef MODULE_REDIR
struct sockaddr_storage dst_addr;
memset(&dst_addr, 0, sizeof(struct sockaddr_storage));
int len = parse_udprealy_header(buf->array, buf->len, NULL, NULL, NULL, &dst_addr);
if (dst_addr.ss_family != AF_INET && dst_addr.ss_family != AF_INET6) {
LOGI("[udp] ss-redir does not support domain name");
goto CLEAN_UP;
}
if (verbose) {
char src[SS_ADDRSTRLEN];
char dst[SS_ADDRSTRLEN];
strcpy(src, get_addr_str((struct sockaddr *)&src_addr));
strcpy(dst, get_addr_str((struct sockaddr *)&dst_addr));
LOGI("[udp] recv %s via %s", dst, src);
}
#else
int len = parse_udprealy_header(buf->array, buf->len, NULL, NULL, NULL, NULL);
#endif
if (len == 0) {
LOGI("[udp] error in parse header");
// error in parse header
goto CLEAN_UP;
}
// server may return using a different address type other than the type we
// have used during sending
#if defined(MODULE_TUNNEL) || defined(MODULE_REDIR)
// Construct packet
buf->len -= len;
memmove(buf->array, buf->array + len, buf->len);
#else
// Construct packet
brealloc(buf, buf->len + 3, buf_size1);
memmove(buf->array + 3, buf->array, buf->len);
memset(buf->array, 0, 3);
buf->len += 3;
#endif
#endif
#ifdef MODULE_REMOTE
rx += buf->len;
char addr_header_buf[512];
char *addr_header = remote_ctx->addr_header;
int addr_header_len = remote_ctx->addr_header_len;
if (remote_ctx->af == AF_INET || remote_ctx->af == AF_INET6) {
addr_header_len = construct_udprealy_header(&src_addr, addr_header_buf);
addr_header = addr_header_buf;
}
// Construct packet
brealloc(buf, buf->len + addr_header_len, buf_size);
memmove(buf->array + addr_header_len, buf->array, buf->len);
memcpy(buf->array, addr_header, addr_header_len);
buf->len += addr_header_len;
int err = ss_encrypt_all(buf, server_ctx->method, 0, buf_size);
if (err) {
// drop the packet silently
goto CLEAN_UP;
}
#endif
if (buf->len > packet_size) {
LOGE("[udp] remote_recv_sendto fragmentation");
goto CLEAN_UP;
}
size_t remote_src_addr_len = get_sockaddr_len((struct sockaddr *)&remote_ctx->src_addr);
#ifdef MODULE_REDIR
size_t remote_dst_addr_len = get_sockaddr_len((struct sockaddr *)&dst_addr);
int src_fd = socket(remote_ctx->src_addr.ss_family, SOCK_DGRAM, 0);
if (src_fd < 0) {
ERROR("[udp] remote_recv_socket");
goto CLEAN_UP;
}
int opt = 1;
if (setsockopt(src_fd, SOL_IP, IP_TRANSPARENT, &opt, sizeof(opt))) {
ERROR("[udp] remote_recv_setsockopt");
close(src_fd);
goto CLEAN_UP;
}
if (setsockopt(src_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
ERROR("[udp] remote_recv_setsockopt");
close(src_fd);
goto CLEAN_UP;
}
#ifdef IP_TOS
// Set QoS flag
int tos = 46;
setsockopt(src_fd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
#endif
if (bind(src_fd, (struct sockaddr *)&dst_addr, remote_dst_addr_len) != 0) {
ERROR("[udp] remote_recv_bind");
close(src_fd);
goto CLEAN_UP;
}
int s = sendto(src_fd, buf->array, buf->len, 0,
(struct sockaddr *)&remote_ctx->src_addr, remote_src_addr_len);
if (s == -1) {
ERROR("[udp] remote_recv_sendto");
close(src_fd);
goto CLEAN_UP;
}
close(src_fd);
#else
int s = sendto(server_ctx->fd, buf->array, buf->len, 0,
(struct sockaddr *)&remote_ctx->src_addr, remote_src_addr_len);
if (s == -1) {
ERROR("[udp] remote_recv_sendto");
goto CLEAN_UP;
}
#endif
// handle the UDP packet successfully,
// triger the timer
ev_timer_again(EV_A_ & remote_ctx->watcher);
CLEAN_UP:
bfree(buf);
ss_free(buf);
}
void
free_addr(ss_addr_t *addr)
{
ss_free(addr->host);
ss_free(addr->port);
}
static void server_recv_cb(EV_P_ ev_io *w, int revents)
{
server_ctx_t *server_ctx = (server_ctx_t *)w;
struct sockaddr_storage src_addr;
memset(&src_addr, 0, sizeof(struct sockaddr_storage));
buffer_t *buf = ss_malloc(sizeof(buffer_t));
balloc(buf, buf_size1);
socklen_t src_addr_len = sizeof(struct sockaddr_storage);
unsigned int offset = 0;
#ifdef MODULE_REDIR
char control_buffer[64] = { 0 };
struct msghdr msg;
struct iovec iov[1];
struct sockaddr_storage dst_addr;
memset(&dst_addr, 0, sizeof(struct sockaddr_storage));
msg.msg_name = &src_addr;
msg.msg_namelen = src_addr_len;
msg.msg_control = control_buffer;
msg.msg_controllen = sizeof(control_buffer);
iov[0].iov_base = buf->array;
iov[0].iov_len = buf_size;
msg.msg_iov = iov;
msg.msg_iovlen = 1;
buf->len = recvmsg(server_ctx->fd, &msg, 0);
if (buf->len == -1) {
ERROR("[udp] server_recvmsg");
goto CLEAN_UP;
} else if (buf->len > packet_size) {
ERROR("[udp] UDP server_recv_recvmsg fragmentation");
goto CLEAN_UP;
}
if (get_dstaddr(&msg, &dst_addr)) {
LOGE("[udp] unable to get dest addr");
goto CLEAN_UP;
}
src_addr_len = msg.msg_namelen;
#else
ssize_t r;
r = recvfrom(server_ctx->fd, buf->array, buf_size1,
0, (struct sockaddr *)&src_addr, &src_addr_len);
if (r == -1) {
// error on recv
// simply drop that packet
ERROR("[udp] server_recv_recvfrom");
goto CLEAN_UP;
} else if (r > packet_size) {
ERROR("[udp] server_recv_recvfrom fragmentation");
goto CLEAN_UP;
}
buf->len = r;
#endif
#ifdef MODULE_REMOTE
tx += buf->len;
int err = ss_decrypt_all(buf, server_ctx->method, server_ctx->auth, buf_size);
if (err) {
// drop the packet silently
goto CLEAN_UP;
}
#endif
#ifdef MODULE_LOCAL
#if !defined(MODULE_TUNNEL) && !defined(MODULE_REDIR)
uint8_t frag = *(uint8_t *)(buf->array + 2);
offset += 3;
#endif
#endif
/*
*
* SOCKS5 UDP Request
* +----+------+------+----------+----------+----------+
* |RSV | FRAG | ATYP | DST.ADDR | DST.PORT | DATA |
* +----+------+------+----------+----------+----------+
* | 2 | 1 | 1 | Variable | 2 | Variable |
* +----+------+------+----------+----------+----------+
*
* SOCKS5 UDP Response
* +----+------+------+----------+----------+----------+
* |RSV | FRAG | ATYP | DST.ADDR | DST.PORT | DATA |
* +----+------+------+----------+----------+----------+
* | 2 | 1 | 1 | Variable | 2 | Variable |
* +----+------+------+----------+----------+----------+
*
* shadowsocks UDP Request (before encrypted)
* +------+----------+----------+----------+-------------+
* | ATYP | DST.ADDR | DST.PORT | DATA | HMAC-SHA1 |
* +------+----------+----------+----------+-------------+
* | 1 | Variable | 2 | Variable | 10 |
* +------+----------+----------+----------+-------------+
*
* If ATYP & ONETIMEAUTH_FLAG(0x10) != 0, Authentication (HMAC-SHA1) is enabled.
*
* The key of HMAC-SHA1 is (IV + KEY) and the input is the whole packet.
* The output of HMAC-SHA is truncated to 10 bytes (leftmost bits).
*
* shadowsocks UDP Response (before encrypted)
* +------+----------+----------+----------+
* | ATYP | DST.ADDR | DST.PORT | DATA |
* +------+----------+----------+----------+
* | 1 | Variable | 2 | Variable |
* +------+----------+----------+----------+
*
* shadowsocks UDP Request and Response (after encrypted)
* +-------+--------------+
* | IV | PAYLOAD |
* +-------+--------------+
* | Fixed | Variable |
* +-------+--------------+
*
*/
#ifdef MODULE_REDIR
if (verbose) {
char src[SS_ADDRSTRLEN];
char dst[SS_ADDRSTRLEN];
strcpy(src, get_addr_str((struct sockaddr *)&src_addr));
strcpy(dst, get_addr_str((struct sockaddr *)&dst_addr));
LOGI("[udp] redir to %s from %s", dst, src);
}
char addr_header[512] = { 0 };
int addr_header_len = construct_udprealy_header(&dst_addr, addr_header);
if (addr_header_len == 0) {
LOGE("[udp] failed to parse tproxy addr");
goto CLEAN_UP;
}
// reconstruct the buffer
brealloc(buf, buf->len + addr_header_len, buf_size);
memmove(buf->array + addr_header_len, buf->array, buf->len);
memcpy(buf->array, addr_header, addr_header_len);
buf->len += addr_header_len;
#elif MODULE_TUNNEL
char addr_header[512] = { 0 };
char *host = server_ctx->tunnel_addr.host;
char *port = server_ctx->tunnel_addr.port;
uint16_t port_num = (uint16_t)atoi(port);
uint16_t port_net_num = htons(port_num);
int addr_header_len = 0;
struct cork_ip ip;
if (cork_ip_init(&ip, host) != -1) {
if (ip.version == 4) {
// send as IPv4
struct in_addr host_addr;
int host_len = sizeof(struct in_addr);
if (dns_pton(AF_INET, host, &host_addr) == -1) {
FATAL("IP parser error");
}
addr_header[addr_header_len++] = 1;
memcpy(addr_header + addr_header_len, &host_addr, host_len);
addr_header_len += host_len;
} else if (ip.version == 6) {
// send as IPv6
struct in6_addr host_addr;
int host_len = sizeof(struct in6_addr);
if (dns_pton(AF_INET6, host, &host_addr) == -1) {
FATAL("IP parser error");
}
addr_header[addr_header_len++] = 4;
memcpy(addr_header + addr_header_len, &host_addr, host_len);
addr_header_len += host_len;
} else {
FATAL("IP parser error");
}
} else {
// send as domain
int host_len = strlen(host);
addr_header[addr_header_len++] = 3;
addr_header[addr_header_len++] = host_len;
memcpy(addr_header + addr_header_len, host, host_len);
addr_header_len += host_len;
}
memcpy(addr_header + addr_header_len, &port_net_num, 2);
addr_header_len += 2;
// reconstruct the buffer
brealloc(buf, buf->len + addr_header_len, buf_size);
memmove(buf->array + addr_header_len, buf->array, buf->len);
memcpy(buf->array, addr_header, addr_header_len);
buf->len += addr_header_len;
#else
char host[257] = { 0 };
char port[64] = { 0 };
struct sockaddr_storage dst_addr;
memset(&dst_addr, 0, sizeof(struct sockaddr_storage));
int addr_header_len = parse_udprealy_header(buf->array + offset, buf->len - offset,
&server_ctx->auth, host, port,
&dst_addr);
if (addr_header_len == 0) {
// error in parse header
goto CLEAN_UP;
}
char *addr_header = buf->array + offset;
#endif
#ifdef MODULE_LOCAL
char *key = hash_key(server_ctx->remote_addr->sa_family, &src_addr);
#else
char *key = hash_key(dst_addr.ss_family, &src_addr);
#endif
struct cache *conn_cache = server_ctx->conn_cache;
remote_ctx_t *remote_ctx = NULL;
cache_lookup(conn_cache, key, HASH_KEY_LEN, (void *)&remote_ctx);
if (remote_ctx != NULL) {
if (sockaddr_cmp(&src_addr, &remote_ctx->src_addr, sizeof(src_addr))) {
remote_ctx = NULL;
}
}
// reset the timer
if (remote_ctx != NULL) {
ev_timer_again(EV_A_ & remote_ctx->watcher);
}
if (remote_ctx == NULL) {
if (verbose) {
#ifdef MODULE_REDIR
char src[SS_ADDRSTRLEN];
char dst[SS_ADDRSTRLEN];
strcpy(src, get_addr_str((struct sockaddr *)&src_addr));
strcpy(dst, get_addr_str((struct sockaddr *)&dst_addr));
LOGI("[udp] cache miss: %s <-> %s", dst, src);
#else
LOGI("[udp] cache miss: %s:%s <-> %s", host, port,
get_addr_str((struct sockaddr *)&src_addr));
#endif
}
} else {
if (verbose) {
#ifdef MODULE_REDIR
char src[SS_ADDRSTRLEN];
char dst[SS_ADDRSTRLEN];
strcpy(src, get_addr_str((struct sockaddr *)&src_addr));
strcpy(dst, get_addr_str((struct sockaddr *)&dst_addr));
LOGI("[udp] cache hit: %s <-> %s", dst, src);
#else
LOGI("[udp] cache hit: %s:%s <-> %s", host, port,
get_addr_str((struct sockaddr *)&src_addr));
#endif
}
}
#ifdef MODULE_LOCAL
#if !defined(MODULE_TUNNEL) && !defined(MODULE_REDIR)
if (frag) {
LOGE("[udp] drop a message since frag is not 0, but %d", frag);
goto CLEAN_UP;
}
#endif
const struct sockaddr *remote_addr = server_ctx->remote_addr;
const int remote_addr_len = server_ctx->remote_addr_len;
if (remote_ctx == NULL) {
// Bind to any port
int remotefd = create_remote_socket(remote_addr->sa_family == AF_INET6);
if (remotefd < 0) {
ERROR("[udp] udprelay bind() error");
goto CLEAN_UP;
}
setnonblocking(remotefd);
#ifdef SO_NOSIGPIPE
set_nosigpipe(remotefd);
#endif
#ifdef IP_TOS
// Set QoS flag
int tos = 46;
setsockopt(remotefd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
#endif
#ifdef SET_INTERFACE
if (server_ctx->iface) {
if (setinterface(remotefd, server_ctx->iface) == -1)
ERROR("setinterface");
}
#endif
#ifdef ANDROID
if (vpn) {
if (protect_socket(remotefd) == -1) {
ERROR("protect_socket");
close(remotefd);
goto CLEAN_UP;
}
}
#endif
// Init remote_ctx
remote_ctx = new_remote(remotefd, server_ctx);
remote_ctx->src_addr = src_addr;
remote_ctx->af = remote_addr->sa_family;
remote_ctx->addr_header_len = addr_header_len;
memcpy(remote_ctx->addr_header, addr_header, addr_header_len);
// Add to conn cache
cache_insert(conn_cache, key, HASH_KEY_LEN, (void *)remote_ctx);
// Start remote io
ev_io_start(EV_A_ & remote_ctx->io);
ev_timer_start(EV_A_ & remote_ctx->watcher);
}
if (offset > 0) {
buf->len -= offset;
memmove(buf->array, buf->array + offset, buf->len);
}
if (server_ctx->auth) {
buf->array[0] |= ONETIMEAUTH_FLAG;
}
int err = ss_encrypt_all(buf, server_ctx->method, server_ctx->auth, buf_size1);
if (err) {
// drop the packet silently
goto CLEAN_UP;
}
if (buf->len > packet_size) {
LOGE("[udp] server_recv_sendto fragmentation");
goto CLEAN_UP;
}
int s = sendto(remote_ctx->fd, buf->array, buf->len, 0, remote_addr, remote_addr_len);
if (s == -1) {
ERROR("[udp] server_recv_sendto");
}
#else
int cache_hit = 0;
int need_query = 0;
if (buf->len - addr_header_len > packet_size) {
LOGE("[udp] server_recv_sendto fragmentation");
goto CLEAN_UP;
}
if (remote_ctx != NULL) {
cache_hit = 1;
// detect destination mismatch
if (remote_ctx->addr_header_len != addr_header_len
|| memcmp(addr_header, remote_ctx->addr_header, addr_header_len) != 0) {
if (dst_addr.ss_family != AF_INET && dst_addr.ss_family != AF_INET6) {
need_query = 1;
}
} else {
memcpy(&dst_addr, &remote_ctx->dst_addr, sizeof(struct sockaddr_storage));
}
} else {
if (dst_addr.ss_family == AF_INET || dst_addr.ss_family == AF_INET6) {
int remotefd = create_remote_socket(dst_addr.ss_family == AF_INET6);
if (remotefd != -1) {
setnonblocking(remotefd);
#ifdef SO_BROADCAST
set_broadcast(remotefd);
#endif
#ifdef SO_NOSIGPIPE
set_nosigpipe(remotefd);
#endif
#ifdef IP_TOS
// Set QoS flag
int tos = 46;
setsockopt(remotefd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
#endif
#ifdef SET_INTERFACE
if (server_ctx->iface) {
if (setinterface(remotefd, server_ctx->iface) == -1)
ERROR("setinterface");
}
#endif
remote_ctx = new_remote(remotefd, server_ctx);
remote_ctx->src_addr = src_addr;
remote_ctx->server_ctx = server_ctx;
remote_ctx->addr_header_len = addr_header_len;
memcpy(remote_ctx->addr_header, addr_header, addr_header_len);
memcpy(&remote_ctx->dst_addr, &dst_addr, sizeof(struct sockaddr_storage));
} else {
ERROR("[udp] bind() error");
goto CLEAN_UP;
}
}
}
if (remote_ctx != NULL && !need_query) {
size_t addr_len = get_sockaddr_len((struct sockaddr *)&dst_addr);
int s = sendto(remote_ctx->fd, buf->array + addr_header_len,
buf->len - addr_header_len, 0,
(struct sockaddr *)&dst_addr, addr_len);
if (s == -1) {
ERROR("[udp] sendto_remote");
if (!cache_hit) {
close_and_free_remote(EV_A_ remote_ctx);
}
} else {
if (!cache_hit) {
// Add to conn cache
remote_ctx->af = dst_addr.ss_family;
char *key = hash_key(remote_ctx->af, &remote_ctx->src_addr);
cache_insert(server_ctx->conn_cache, key, HASH_KEY_LEN, (void *)remote_ctx);
ev_io_start(EV_A_ & remote_ctx->io);
ev_timer_start(EV_A_ & remote_ctx->watcher);
}
}
} else {
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
struct query_ctx *query_ctx = new_query_ctx(buf->array + addr_header_len,
buf->len - addr_header_len);
query_ctx->server_ctx = server_ctx;
query_ctx->addr_header_len = addr_header_len;
query_ctx->src_addr = src_addr;
memcpy(query_ctx->addr_header, addr_header, addr_header_len);
if (need_query) {
query_ctx->remote_ctx = remote_ctx;
}
struct ResolvQuery *query = resolv_query(host, query_resolve_cb,
NULL, query_ctx, htons(atoi(port)));
if (query == NULL) {
ERROR("[udp] unable to create DNS query");
close_and_free_query(EV_A_ query_ctx);
goto CLEAN_UP;
}
query_ctx->query = query;
}
#endif
CLEAN_UP:
bfree(buf);
ss_free(buf);
}
int
start_plugin(const char *plugin,
const char *plugin_opts,
const char *remote_host,
const char *remote_port,
const char *local_host,
const char *local_port)
{
char *new_path = NULL;
char *cmd = NULL;
if (plugin == NULL)
return -1;
if (strlen(plugin) == 0)
return 0;
size_t plugin_len = strlen(plugin);
size_t cmd_len = plugin_len + CMD_RESRV_LEN;
cmd = ss_malloc(cmd_len);
snprintf(cmd, cmd_len, "exec %s", plugin);
env = cork_env_clone_current();
const char *path = cork_env_get(env, "PATH");
if (path != NULL) {
#ifdef __GLIBC__
char *cwd = get_current_dir_name();
if (cwd) {
#else
char cwd[PATH_MAX];
if (!getcwd(cwd, PATH_MAX)) {
#endif
size_t path_len = strlen(path) + strlen(cwd) + 2;
new_path = ss_malloc(path_len);
snprintf(new_path, path_len, "%s:%s", cwd, path);
#ifdef __GLIBC__
free(cwd);
#endif
}
}
if (new_path != NULL)
cork_env_add(env, "PATH", new_path);
cork_env_add(env, "SS_REMOTE_HOST", remote_host);
cork_env_add(env, "SS_REMOTE_PORT", remote_port);
cork_env_add(env, "SS_LOCAL_HOST", local_host);
cork_env_add(env, "SS_LOCAL_PORT", local_port);
if (plugin_opts != NULL)
cork_env_add(env, "SS_PLUGIN_OPTIONS", plugin_opts);
exec = cork_exec_new_with_params("sh", "-c", cmd, NULL);
cork_exec_set_env(exec, env);
sub = cork_subprocess_new_exec(exec, NULL, NULL, &exit_code);
int err = cork_subprocess_start(sub);
ss_free(cmd);
if (new_path != NULL)
ss_free(new_path);
return err;
}
uint16_t
get_local_port()
{
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
return 0;
}
struct sockaddr_in serv_addr;
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = 0;
if (bind(sock, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
return 0;
}
socklen_t len = sizeof(serv_addr);
if (getsockname(sock, (struct sockaddr *)&serv_addr, &len) == -1) {
return 0;
}
if (close (sock) < 0) {
return 0;
}
return ntohs(serv_addr.sin_port);
}
void
stop_plugin()
{
if (sub != NULL) {
cork_subprocess_abort(sub);
cork_subprocess_free(sub);
}
}
int is_plugin_running()
{
if (sub != NULL) {
return cork_subprocess_is_finished(sub);
}
return 0;
}
/*
* For obfsproxy, we use standalone mode for now.
* Managed mode needs to use SOCKS5 proxy as forwarder, which is not supported
* yet.
*
* The idea of using standalone mode is quite simple, just assemble the
* internal port into obfsproxy parameters.
*
* Using manually ran scramblesuit as an example:
* obfsproxy \
* --data-dir /tmp/ss_libev_plugin_with_suffix \
* scramblesuit \
* --password SOMEMEANINGLESSPASSWORDASEXAMPLE \
* --dest some.server.org:12345 \
* client \
* 127.0.0.1:54321
*
* In above case, @plugin = "obfsproxy",
* @plugin_opts = "scramblesuit --password SOMEMEANINGLESSPASSWORDASEXAMPLE"
* For obfs3, it's even easier, just pass @plugin = "obfsproxy"
* @plugin_opts = "obfs3"
*
* And the rest parameters are all assembled here.
* Some old obfsproxy will not be supported as it doesn't even support
* "--data-dir" option
*/
static int
start_obfsproxy(const char *plugin,
const char *plugin_opts,
const char *remote_host,
const char *remote_port,
const char *local_host,
const char *local_port,
enum plugin_mode mode)
{
char *pch;
char *opts_dump = NULL;
char *buf = NULL;
int ret, buf_size = 0;
if (plugin_opts != NULL) {
opts_dump = strndup(plugin_opts, OBFSPROXY_OPTS_MAX);
if (!opts_dump) {
ERROR("start_obfsproxy strndup failed");
if (env != NULL) {
cork_env_free(env);
}
return -ENOMEM;
}
}
exec = cork_exec_new(plugin);
/* The first parameter will be skipped, so pass @plugin again */
cork_exec_add_param(exec, plugin);
cork_exec_add_param(exec, "--data-dir");
buf_size = 20 + strlen(plugin) + strlen(remote_host)
+ strlen(remote_port) + strlen(local_host) + strlen(local_port);
buf = ss_malloc(buf_size);
snprintf(buf, buf_size, TEMPDIR "%s_%s:%s_%s:%s", plugin,
remote_host, remote_port, local_host, local_port);
cork_exec_add_param(exec, buf);
/*
* Iterate @plugin_opts by space
*/
if (opts_dump != NULL) {
pch = strtok(opts_dump, " ");
while (pch) {
cork_exec_add_param(exec, pch);
pch = strtok(NULL, " ");
}
}
/* The rest options */
if (mode == MODE_CLIENT) {
/* Client mode */
cork_exec_add_param(exec, "--dest");
snprintf(buf, buf_size, "%s:%s", remote_host, remote_port);
cork_exec_add_param(exec, buf);
cork_exec_add_param(exec, "client");
snprintf(buf, buf_size, "%s:%s", local_host, local_port);
cork_exec_add_param(exec, buf);
} else {
/* Server mode */
cork_exec_add_param(exec, "--dest");
snprintf(buf, buf_size, "%s:%s", local_host, local_port);
cork_exec_add_param(exec, buf);
cork_exec_add_param(exec, "server");
snprintf(buf, buf_size, "%s:%s", remote_host, remote_port);
cork_exec_add_param(exec, buf);
}
cork_exec_set_env(exec, env);
sub = cork_subprocess_new_exec(exec, NULL, NULL, &exit_code);
#ifdef __MINGW32__
cork_subprocess_set_control(sub, sub_control_port);
#endif
ret = cork_subprocess_start(sub);
ss_free(opts_dump);
free(buf);
return ret;
}
int si_schemerecover(sischeme *s, sr *r)
{
sdscheme c;
sd_schemeinit(&c);
char path[PATH_MAX];
snprintf(path, sizeof(path), "%s/scheme", s->path);
int rc;
rc = sd_schemerecover(&c, r, path);
if (ssunlikely(rc == -1))
goto error;
ssiter i;
ss_iterinit(sd_schemeiter, &i);
rc = ss_iteropen(sd_schemeiter, &i, r, &c, 1);
if (ssunlikely(rc == -1))
goto error;
while (ss_iterhas(sd_schemeiter, &i))
{
sdschemeopt *opt = ss_iterof(sd_schemeiter, &i);
switch (opt->id) {
case SI_SCHEME_FORMAT:
s->fmt = sd_schemeu32(opt);
char *name;
if (s->fmt == SF_KV)
name = "kv";
else
if (s->fmt == SF_DOCUMENT)
name = "document";
else
goto error;
ss_free(r->a, s->fmt_sz);
s->fmt_sz = ss_strdup(r->a, name);
if (ssunlikely(s->fmt_sz == NULL))
goto error;
break;
case SI_SCHEME_FORMAT_STORAGE:
s->fmt_storage = sd_schemeu32(opt);
break;
case SI_SCHEME_SCHEME: {
sr_schemefree(&s->scheme, r->a);
sr_schemeinit(&s->scheme);
ssbuf buf;
ss_bufinit(&buf);
rc = sr_schemeload(&s->scheme, r->a, sd_schemesz(opt), opt->size);
if (ssunlikely(rc == -1))
goto error;
ss_buffree(&buf, r->a);
break;
}
case SI_SCHEME_NODE_SIZE:
s->node_size = sd_schemeu64(opt);
break;
case SI_SCHEME_NODE_PAGE_SIZE:
s->node_page_size = sd_schemeu32(opt);
break;
case SI_SCHEME_COMPRESSION_KEY:
s->compression_key = sd_schemeu32(opt);
break;
case SI_SCHEME_COMPRESSION: {
char *name = sd_schemesz(opt);
ssfilterif *cif = ss_filterof(name);
if (ssunlikely(cif == NULL))
goto error;
s->compression_if = cif;
s->compression = s->compression_if != &ss_nonefilter;
ss_free(r->a, s->compression_sz);
s->compression_sz = ss_strdup(r->a, cif->name);
if (ssunlikely(s->compression_sz == NULL))
goto error;
break;
}
case SI_SCHEME_COMPRESSION_BRANCH: {
char *name = sd_schemesz(opt);
ssfilterif *cif = ss_filterof(name);
if (ssunlikely(cif == NULL))
goto error;
s->compression_branch_if = cif;
s->compression_branch = s->compression_branch_if != &ss_nonefilter;
ss_free(r->a, s->compression_branch_sz);
s->compression_branch_sz = ss_strdup(r->a, cif->name);
if (ssunlikely(s->compression_branch_sz == NULL))
goto error;
break;
}
case SI_SCHEME_AMQF:
s->amqf = sd_schemeu32(opt);
break;
case SI_SCHEME_CACHE_MODE:
s->cache_mode = sd_schemeu32(opt);
break;
case SI_SCHEME_EXPIRE:
s->expire = sd_schemeu32(opt);
break;
default: /* skip unknown */
break;
}
ss_iternext(sd_schemeiter, &i);
}
sd_schemefree(&c, r);
return 0;
error:
sd_schemefree(&c, r);
return -1;
}
