static inline void
freesocket(struct silly_socket *ss, struct socket *s)
{
(void)ss;
wlist_free(s);
assert(s->wlhead.next == NULL);
__sync_synchronize();
s->type = STYPE_RESERVE;
}
struct write_list *
config_mbr(struct disk_info *dinfo)
{
struct part_info *pinfo;
uint32_t cur_lba = dinfo->skip_lba;
uint32_t ext_lba = 0;
struct write_list *wr_list = NULL;
struct write_list *temp_wr = NULL;
int cnt = 0;
int extended = 0;
if (!dinfo->part_lst)
return NULL;
for (cnt = 0; cnt < dinfo->num_parts; ++cnt) {
pinfo = &dinfo->part_lst[cnt];
/* Should we create an extedned partition? */
if (cnt == (PC_NUM_BOOT_RECORD_PARTS - 1)) {
if (cnt + 1 < dinfo->num_parts) {
extended = 1;
ext_lba = cur_lba;
if ((temp_wr = mk_pri_pentry(dinfo, NULL, cnt, &cur_lba)))
wlist_add(&wr_list, temp_wr);
else {
LOGE("Cannot create primary extended partition.");
goto fail;
}
}
}
/* if extended, need 1 lba for ebr */
if ((cur_lba + extended) >= dinfo->num_lba)
goto nospace;
else if (pinfo->len_kb != (uint32_t)-1) {
uint32_t sz_lba = (pinfo->len_kb / dinfo->sect_size) * 1024;
if ((cur_lba + sz_lba + extended) > dinfo->num_lba)
goto nospace;
}
if (!extended)
temp_wr = mk_pri_pentry(dinfo, pinfo, cnt, &cur_lba);
else {
struct part_info *pnext;
pnext = cnt + 1 < dinfo->num_parts ? &dinfo->part_lst[cnt+1] : NULL;
temp_wr = mk_ext_pentry(dinfo, pinfo, &cur_lba, ext_lba, pnext);
}
if (temp_wr)
wlist_add(&wr_list, temp_wr);
else {
LOGE("Cannot create partition %d (%s).", cnt, pinfo->name);
goto fail;
}
}
/* fill in the rest of the MBR with empty parts (if needed). */
for (; cnt < PC_NUM_BOOT_RECORD_PARTS; ++cnt) {
struct part_info blank;
cur_lba = 0;
memset(&blank, 0, sizeof(struct part_info));
if (!(temp_wr = mk_pri_pentry(dinfo, &blank, cnt, &cur_lba))) {
LOGE("Cannot create blank partition %d.", cnt);
goto fail;
}
wlist_add(&wr_list, temp_wr);
}
return wr_list;
nospace:
LOGE("Not enough space to add parttion '%s'.", pinfo->name);
fail:
wlist_free(wr_list);
return NULL;
}
int main(int argc, char **argv)
{
int c;
size_t i;
size_t n_phrases = 1;
size_t out_idx[WORDS_MAX];
/* words to choose from */
char *words[WORDS_MAX];
size_t n_words = 0, n_chars = 0;
/* minimum lengths to generate */
size_t chars_min = CHARS_MIN_DEFAULT;
size_t words_min = WORDS_MIN_DEFAULT;
/* user-specified wordlists */
struct wlist *wlists[WLISTS_MAX];
size_t i_wlists = 0, n_wlists = 0;
/* user-specified words */
char *uwords[UWORDS_MAX];
size_t i_uwords = 0, n_uwords = 0;
/* sep character between words, -1 -> none */
int sep = -1;
int camel = 0;
/* for strtoul */
char *endptr;
/* arguments */
#ifdef _GNU_SOURCE
struct option long_opts[] = {
{ "include", required_argument, NULL, 'i' },
{ "list", required_argument, NULL, 'l' },
{ "chars", required_argument, NULL, 'c' },
{ "words", required_argument, NULL, 'w' },
{ "sep", required_argument, NULL, 's' },
{ "uppercase", no_argument, NULL, 'u' },
{ "camelcase", no_argument, NULL, 'u' },
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, 'v' },
{ 0, 0, 0, 0 }
};
while ((c = getopt_long(argc, argv, "hvi:l:c:w:s:u", long_opts, NULL)) != -1)
#else
while ((c = getopt(argc, argv, "hvi:l:c:w:s:u")) != -1)
#endif
{
switch (c)
{
case 'h':
print_usage(argv[0]);
exit(EXIT_SUCCESS);
case 'v':
print_version(argv[0]);
exit(EXIT_SUCCESS);
case 'i':
uwords[i_uwords] = optarg;
n_uwords = (n_uwords < UWORDS_MAX) ? n_uwords + 1 : UWORDS_MAX;
i_uwords = (i_uwords + 1) % UWORDS_MAX;
break;
case 'l':
wlists[i_wlists] = wlist_read(optarg);
if (wlists[i_wlists])
{
n_wlists = (n_wlists < WLISTS_MAX) ? n_wlists + 1 : WLISTS_MAX;
i_wlists = (i_wlists + 1) % WLISTS_MAX;
}
break;
case 'c':
chars_min = strtoul(optarg, &endptr, 10);
if (*endptr != '\0')
{
fprintf(stderr, "invalid number: %s\n", optarg);
exit(EXIT_FAILURE);
}
chars_min = (chars_min > CHARS_MAX) ? CHARS_MAX : chars_min;
break;
case 'w':
words_min = strtoul(optarg, &endptr, 10);
if (*endptr != '\0')
{
fprintf(stderr, "invalid number: %s\n", optarg);
exit(EXIT_FAILURE);
}
words_min = (words_min > WORDS_MAX) ? WORDS_MAX : words_min;
break;
case 's':
sep = *optarg;
break;
case 'u':
camel = 1;
break;
case '?':
exit(EXIT_FAILURE);
}
}
if (optind < argc)
{
n_phrases = strtoul(argv[optind], &endptr, 10);
if (*endptr != '\0')
{
fprintf(stderr, "invalid number: %s\n", argv[optind]);
exit(EXIT_FAILURE);
}
}
/* no user-specified wordlists, use default */
if (!n_wlists)
{
wlists[0] = wlist_read(WORDLIST_DEFAULT);
if (!wlists[0])
{
fprintf(stderr, "couldn't read default wordlist\n");
exit(EXIT_FAILURE);
}
n_wlists = 1;
}
while (n_phrases--)
{
n_chars = 0;
n_words = 0;
for (; n_words < n_uwords; ++n_words)
{
words[n_words] = uwords[n_words];
n_chars += strlen(words[n_words]);
}
for (; n_words < words_min || n_chars < chars_min; ++n_words)
{
size_t iwl, iw;
iwl = rand_index(n_wlists);
iw = rand_index(wlists[iwl]->len);
words[n_words] = wlist_get(wlists[iwl], iw);
n_chars += strlen(words[n_words]);
}
if (camel)
{
for (i = 0; i < n_words; ++i)
*words[i] = toupper(*words[i]);
}
rand_perm(out_idx, n_words);
for (i = 0; i < n_words; ++i)
{
if (i && sep != -1)
printf("%c", sep);
printf("%s", words[out_idx[i]]);
}
printf("\n");
}
for (i = 0; i < n_wlists; ++i)
wlist_free(wlists[i]);
return EXIT_SUCCESS;
}
