static bool sort_by_qtime(std::string a, std::string b)
{
const char *pa=strchr(a.c_str(), '.')+1;
const char *pb=strchr(b.c_str(), '.')+1;
time_t ta=strtotime(pa);
time_t tb=strtotime(pb);
return ta < tb;
}
int main()
{
const char date[] = "Tue, 20-Mar-2007 14:31:38 GMT";
time_t t = strtotime(date);
time_t n = time(NULL);
printf("%ld => %ld\n", t, n);
return 0;
}
/**
* Checks if Session-Expires value is over Min_SE local policy
* @param msg - the initial request
* @param str1 - not used
* @param str2 - not used
* @returns #CSCF_RETURN_TRUE if ok, #CSCF_RETURN_FALSE if not
*/
int S_check_session_expires(struct sip_msg* msg, char* str1, char* str2)
{
time_t t_time;
time_t min_se_time = 0;
str ses_exp = {0,0};
str min_se = {0,0};
str new_min_se = {0,0};
str new_ses_exp = {0,0};
struct hdr_field *h_se, *h_min_se;
str refresher;
ses_exp = cscf_get_session_expires_body(msg, &h_se);
t_time = cscf_get_session_expires(ses_exp, &refresher);
if (!t_time || t_time >= scscf_min_se)
return CSCF_RETURN_TRUE;
if (!supports_extension(msg, &str_ext_timer)) //does not suports timer extension
{
//add Min-SE header with its minimum interval
min_se = cscf_get_min_se(msg, &h_min_se);
if (min_se.len) {
strtotime(min_se, min_se_time);
if (min_se_time < scscf_min_se)
cscf_del_header(msg, h_min_se);
else
return CSCF_RETURN_TRUE;
}
new_min_se.len = 11/*int value*/ + str_min_se.len+3;
new_min_se.s = pkg_malloc(new_min_se.len+1);
if (!new_min_se.s) {
LOG(L_ERR,"ERR:"M_NAME":S_check_session_expires: Error allocating %d bytes\n",new_min_se.len);
goto error;
}
new_min_se.len = snprintf(new_min_se.s, new_min_se.len, "%.*s %d\r\n",str_min_se.len, str_min_se.s, scscf_min_se);
min_se_time = scscf_min_se;
cscf_add_header(msg, &new_min_se, HDR_OTHER_T);
if (t_time < scscf_min_se) {
cscf_del_header(msg, h_se);
new_ses_exp.len = 11 + str_se.len+3;
new_ses_exp.s = pkg_malloc(new_ses_exp.len+1);
if (!new_ses_exp.s) {
LOG(L_ERR,"ERR:"M_NAME":S_check_session_expires: Error allocating %d bytes\n",new_ses_exp.len);
goto error;
}
new_ses_exp.len = snprintf(new_ses_exp.s, new_ses_exp.len, "%.*s %d\r\n",str_se.len, str_se.s, scscf_min_se);
t_time = scscf_min_se;
cscf_add_header(msg, &new_ses_exp, HDR_OTHER_T);
}
return CSCF_RETURN_TRUE;
}
error:
if (new_min_se.s) pkg_free(new_min_se.s);
if (new_ses_exp.s) pkg_free(new_ses_exp.s);
return CSCF_RETURN_FALSE;
}
void set_seek_opt(ogg123_options_t *ogg123_opts, char *buf) {
char *b = buf;
/* skip spaces */
while (*b && (*b == ' ')) b++;
if (*b == '-') {
/* relative seek back */
ogg123_opts->seekoff = -1 * strtotime(b+1);
ogg123_opts->seekmode = DECODER_SEEK_CUR;
} else
if (*b == '+') {
/* relative seek forward */
ogg123_opts->seekoff = strtotime(b+1);
ogg123_opts->seekmode = DECODER_SEEK_CUR;
} else {
/* absolute seek */
ogg123_opts->seekoff = strtotime(b);
ogg123_opts->seekmode = DECODER_SEEK_START;
}
}
static void undump(FILE *in, FILE *out)
{
struct utmp ut;
char s_addr[INET6_ADDRSTRLEN + 1], s_time[29], *linestart, *line;
int count = 0;
linestart = xmalloc(1024 * sizeof(*linestart));
s_time[28] = 0;
while (fgets(linestart, 1023, in)) {
line = linestart;
memset(&ut, '\0', sizeof(ut));
sscanf(line, "[%hd] [%d] [%4c] ", &ut.ut_type, &ut.ut_pid, ut.ut_id);
line += 19;
line += gettok(line, ut.ut_user, sizeof(ut.ut_user), 1);
line += gettok(line, ut.ut_line, sizeof(ut.ut_line), 1);
line += gettok(line, ut.ut_host, sizeof(ut.ut_host), 1);
line += gettok(line, s_addr, sizeof(s_addr) - 1, 1);
gettok(line, s_time, sizeof(s_time) - 1, 0);
if (strchr(s_addr, '.'))
inet_pton(AF_INET, s_addr, &(ut.ut_addr_v6));
else
inet_pton(AF_INET6, s_addr, &(ut.ut_addr_v6));
#if defined(_HAVE_UT_TV)
ut.ut_tv.tv_sec = strtotime(s_time);
#else
ut.ut_time = strtotime(s_time);
#endif
ignore_result( fwrite(&ut, sizeof(ut), 1, out) );
++count;
}
free(linestart);
}
int GetParamTime(const char* pszString, const char* pszParam, int iDefault)
{
if (!pszString || !pszParam)
return iDefault;
int iRet = iDefault;
char* pszTemp = reinterpret_cast<char*>(alloca(strlen(pszString)+1));
if (!pszTemp)
return 0;
strcpy(pszTemp, pszString);
char* pszSep, *pszToken;
for (pszSep = pszTemp, pszToken = strqsep(&pszSep, g_pszParamDelim, g_pszQuotes);
pszToken; pszToken = strqsep(&pszSep, g_pszParamDelim, g_pszQuotes))
{
while (isspace(*pszToken)) ++pszToken;
char* pszStart = strchr(pszToken, '=');
if (pszStart)
*pszStart++ = '\0';
if (!_stricmp(pszToken, pszParam))
{
if (!pszStart)
break;
while (isspace(*pszStart)) ++pszStart;
char* pszEnd = pszStart + strlen(pszStart);
if (*pszStart == '\"' || *pszStart == '\'')
{
if (*(pszEnd-1) == *pszStart)
*(--pszEnd) = '\0';
++pszStart;
}
if (*pszStart == '$')
{
++pszStart;
if (pszEnd > pszStart)
{
SService<IQuestSrv> pQS(g_pScriptManager);
if (pQS->Exists(pszStart))
iRet = pQS->Get(pszStart);
}
}
else
{
iRet = strtotime(pszStart);
}
break;
}
}
return iRet;
}
undump(FILE *fp, int forever, int oldfmt)
#endif
{
struct utmp ut;
struct oldutmp uto;
char s_addr[16], s_time[29], *linestart, *line;
int count = 0;
line = linestart = malloc(1024 * sizeof *linestart);
s_addr[15] = 0;
s_time[28] = 0;
while(fgets(linestart, 1023, fp))
{
line = linestart;
memset(&ut, '\0', sizeof(ut));
sscanf(line, "[%hd] [%d] [%4c] ", &ut.ut_type, &ut.ut_pid, ut.ut_id);
line += 19;
line += gettok(line, ut.ut_user, sizeof(ut.ut_user), 1);
line += gettok(line, ut.ut_line, sizeof(ut.ut_line), 1);
line += gettok(line, ut.ut_host, sizeof(ut.ut_host), 1);
line += gettok(line, s_addr, sizeof(s_addr)-1, 1);
line += gettok(line, s_time, sizeof(s_time)-1, 0);
ut.ut_addr = inet_addr(s_addr);
ut.ut_time = strtotime(s_time);
if (oldfmt) {
uto = newtoold(ut);
fwrite(&uto, sizeof(uto), 1, stdout);
} else
fwrite(&ut, sizeof(ut), 1, stdout);
++count;
}
free(linestart);
}
int parse_cmdline_options (int argc, char **argv,
ogg123_options_t *ogg123_opts,
file_option_t *file_opts)
{
int option_index = 1;
ao_option *temp_options = NULL;
ao_option ** current_options = &temp_options;
ao_info *info;
int temp_driver_id = -1;
audio_device_t *current;
int ret;
while (-1 != (ret = getopt_long(argc, argv, "b:c::d:f:hl:k:K:o:p:qvVx:y:z@:",
long_options, &option_index))) {
switch (ret) {
case 0:
if(!strcmp(long_options[option_index].name, "audio-buffer")) {
ogg123_opts->buffer_size = 1024 * atoi(optarg);
} else {
status_error(_("Internal error parsing command line options.\n"));
exit(1);
}
break;
case 'b':
ogg123_opts->input_buffer_size = atoi(optarg) * 1024;
if (ogg123_opts->input_buffer_size < MIN_INPUT_BUFFER_SIZE * 1024) {
status_error(_("Input buffer size smaller than minimum size of %dkB."),
MIN_INPUT_BUFFER_SIZE);
ogg123_opts->input_buffer_size = MIN_INPUT_BUFFER_SIZE * 1024;
}
break;
case 'c':
if (optarg) {
char *tmp = strdup (optarg);
parse_code_t pcode = parse_line(file_opts, tmp);
if (pcode != parse_ok)
status_error(_("=== Error \"%s\" while parsing config option from command line.\n"
"=== Option was: %s\n"),
parse_error_string(pcode), optarg);
free (tmp);
}
else {
/* not using the status interface here */
fprintf (stdout, _("Available options:\n"));
file_options_describe(file_opts, stdout);
exit (0);
}
break;
case 'd':
temp_driver_id = ao_driver_id(optarg);
if (temp_driver_id < 0) {
status_error(_("=== No such device %s.\n"), optarg);
exit(1);
}
current = append_audio_device(ogg123_opts->devices,
temp_driver_id,
NULL, NULL);
if(ogg123_opts->devices == NULL)
ogg123_opts->devices = current;
current_options = ¤t->options;
break;
case 'f':
if (temp_driver_id >= 0) {
info = ao_driver_info(temp_driver_id);
if (info->type == AO_TYPE_FILE) {
free(current->filename);
current->filename = strdup(optarg);
} else {
status_error(_("=== Driver %s is not a file output driver.\n"),
info->short_name);
exit(1);
}
} else {
status_error(_("=== Cannot specify output file without specifying a driver.\n"));
exit (1);
}
break;
case 'k':
ogg123_opts->seekpos = strtotime(optarg);
break;
case 'K':
ogg123_opts->endpos = strtotime(optarg);
break;
case 'l':
ogg123_opts->delay = atoi(optarg);
break;
case 'o':
if (optarg && !add_ao_option(current_options, optarg)) {
status_error(_("=== Incorrect option format: %s.\n"), optarg);
exit(1);
}
break;
case 'h':
cmdline_usage();
exit(0);
break;
case 'p':
ogg123_opts->input_prebuffer = atof (optarg);
if (ogg123_opts->input_prebuffer < 0.0f ||
ogg123_opts->input_prebuffer > 100.0f) {
status_error (_("--- Prebuffer value invalid. Range is 0-100.\n"));
ogg123_opts->input_prebuffer =
ogg123_opts->input_prebuffer < 0.0f ? 0.0f : 100.0f;
}
break;
case 'q':
ogg123_opts->verbosity = 0;
break;
case 'v':
ogg123_opts->verbosity++;
break;
case 'V':
status_error(_("ogg123 from %s %s\n"), PACKAGE, VERSION);
exit(0);
break;
case 'x':
ogg123_opts->nth = atoi(optarg);
if (ogg123_opts->nth == 0) {
status_error(_("--- Cannot play every 0th chunk!\n"));
ogg123_opts->nth = 1;
}
break;
case 'y':
ogg123_opts->ntimes = atoi(optarg);
if (ogg123_opts->ntimes == 0) {
status_error(_("--- Cannot play every chunk 0 times.\n"
"--- To do a test decode, use the null output driver.\n"));
ogg123_opts->ntimes = 1;
}
break;
case 'z':
ogg123_opts->shuffle = 1;
break;
case '@':
if (playlist_append_from_file(ogg123_opts->playlist, optarg) == 0)
status_error(_("--- Cannot open playlist file %s. Skipped.\n"),
optarg);
break;
case '?':
break;
default:
cmdline_usage();
exit(1);
}
}
/* Sanity check bad option combinations */
if (ogg123_opts->endpos > 0.0 &&
ogg123_opts->seekpos > ogg123_opts->endpos) {
status_error(_("=== Option conflict: End time is before start time.\n"));
exit(1);
}
/* Add last device to device list or use the default device */
if (temp_driver_id < 0) {
/* First try config file setting */
if (ogg123_opts->default_device) {
temp_driver_id = ao_driver_id(ogg123_opts->default_device);
if (temp_driver_id < 0)
status_error(_("--- Driver %s specified in configuration file invalid.\n"),
ogg123_opts->default_device);
}
/* Then try libao autodetect */
if (temp_driver_id < 0)
temp_driver_id = ao_default_driver_id();
/* Finally, give up */
if (temp_driver_id < 0) {
status_error(_("=== Could not load default driver and no driver specified in config file. Exiting.\n"));
exit(1);
}
ogg123_opts->devices = append_audio_device(ogg123_opts->devices,
temp_driver_id,
temp_options,
NULL);
}
return optind;
}
static int faxsend_cleanup(int errcode, char *errmsg, void *vp)
{
struct faxconv_err_args *args=(struct faxconv_err_args *)vp;
unsigned pages_sent=0;
char *p, *q;
int i;
time_t now_time;
unsigned coverpage_cnt=0;
unsigned page_cnt=0;
/* Check how many files sendfax renamed (were succesfully sent) */
while (args->file_list)
{
if (access(args->file_list->filename, 0) == 0)
break;
if (coverpage_cnt < args->n_cover_pages)
++coverpage_cnt;
else
++pages_sent;
args->file_list=args->file_list->next;
}
/* Strip out any blank lines in captured output from sendfax */
for (p=q=errmsg; *p; p++)
{
if (*p == '\n' && (p[1] == '\n' || p[1] == 0))
continue;
*q++=*p;
}
*q=0;
/* Find the last message from sendfax */
for (p=q=errmsg; *p; p++)
{
if (*p != '\n')
continue;
*p=0;
/* Dump sendfax's output to the log */
if (*q)
{
clog_msg_start_info();
clog_msg_str("courierfax: " SENDFAX ": ");
clog_msg_str(q);
clog_msg_send();
}
q=p+1;
}
if (*q) /* Last line of the error message */
{
clog_msg_start_info();
clog_msg_str("courierfax: " SENDFAX ": ");
clog_msg_str(q);
clog_msg_send();
}
else /* Default message */
{
q=SENDFAX ": completed.";
}
/*
** Ugly hack: capture the following message from sendfax:
**
** /usr/sbin/sendfax: cannot access fax device(s) (locked?)
*/
#if 0
lockflag=0;
p=strchr(q, ':');
if (p)
{
static const char msg1[]="cannot access fax device";
static const char msg2[]="locked";
++p;
while (*p && isspace((int)(unsigned char)*p))
p++;
if (*p && strncasecmp(p, msg1, sizeof(msg1)-1) == 0)
{
p += sizeof(msg1);
while (*p && !isspace((int)(unsigned char)*p))
++p;
p=strchr(p, '(');
if (p && strncmp(p+1, msg2, sizeof(msg2)-1) == 0)
{
args->is_locked=1;
clog_msg_start_info();
clog_msg_str("courierfax: detected locked"
" modem line, sleeping...");
clog_msg_send();
sleep(60);
return (-1);
}
}
}
#else
if (errcode == 2)
{
args->is_locked=1;
clog_msg_start_info();
clog_msg_str("courierfax: detected locked"
" modem line, sleeping...");
clog_msg_send();
sleep(60);
return (-1);
}
#endif
ctlfile_append_connectioninfo(args->ctf, args->nreceip,
COMCTLFILE_DELINFO_REPLY, q);
sprintf(errmsg, "%u cover pages, %u document pages sent.",
coverpage_cnt, page_cnt);
i=ctlfile_searchfirst(args->ctf, COMCTLFILE_FAXEXPIRES);
time(&now_time);
ctlfile_append_reply(args->ctf, args->nreceip,
errmsg,
(pages_sent == 0 &&
i >= 0 &&
errcode < 10 &&
now_time < strtotime(args->ctf->lines[i]+1)
? COMCTLFILE_DELDEFERRED:
COMCTLFILE_DELFAIL_NOTRACK), 0);
return (-1);
}
void aggregator_refresh(map <string, string> &feed)
{
// Generate conditional GET headers.
map <string, string> headers;
if ( isset(feed["etag"]) )
{
headers["If-None-Match"] = feed["etag"];
}
if ( isset(feed["modified"]) )
{
headers["If-Modified-Since"] = gmdate("D, d M Y H:i:s", feed["modified"]) + " GMT";
}
map <string, string> result;
// Request feed.
http_request( result, feed["url"], headers );
// Process HTTP response code.
switch ( intval( result["response_code"] ) )
{
case 304:
if(DB_TYPE==1)
redis_command("HSET aggregator_feed:%d checked %d", intval(feed["fid"]), time() );
if(DB_TYPE==2)
db_querya("UPDATE aggregator_feed SET checked = %d WHERE fid = %d", str( time() ).c_str(), feed["fid"].c_str() );
set_page_message( "There is no new syndicated content from " + feed["title"] );
break;
case 301:
feed["url"] = result["redirect_url"];
case 200:
case 302:
case 307:
// Filter the input data:
if ( aggregator_parse_feed( result["data"], feed ) )
{
string modified = !isset2(result,"Last-Modified") ? "0" : strtotime( result["Last-Modified"] );
// Prepare the channel data.
for( map <string, string>::iterator curr = channel.begin(), end = channel.end(); curr != end; curr++ )
{
trim( curr->second );
channel[curr->first] = curr->second;
}
// Prepare the image data (if any).
for( map <string, string>::iterator curr = image.begin(), end = image.end(); curr != end; curr++ )
{
trim( curr->second );
image[curr->first] = curr->second;
}
string str_image;
if (isset(image["LINK"]) && isset(image["URL"]) && isset(image["TITLE"]) )
{
// Note, we should really use theme_image() here but that only works with local images it won't work with images fetched with a URL unless PHP version > 5
str_image = "<a href=\""+ check_url(image["LINK"]) +"\" class=\"feed-image\"><img src=\"" + check_url(image["URL"]) + "\" alt=\"" + check_plain(image["TITLE"]) +"\" /></a>";
}
else {
str_image = "";
}
string etag = !isset(result["ETag"]) ? "" : result["ETag"];
// Update the feed data.
if(DB_TYPE==1)
{
redis_command_fields(redis_arg("HMSET aggregator_feed:%d", intval(feed["fid"]) ), "",
"url,checked,link,description,image,etag,modified", "%s,%d,%s,%s,%s,%s,%d",
feed["url"].c_str(),
time(),
channel["LINK"].c_str(),
channel["DESCRIPTION"].c_str(),
str_image.c_str(),
etag.c_str(),
intval( modified ) );
}
if(DB_TYPE==2)
{
db_querya("UPDATE aggregator_feed SET url = '%s', checked = %d, link = '%s', description = '%s', image = '%s', etag = '%s', modified = %d WHERE fid = %d",
feed["url"].c_str(),
str(time()).c_str(),
channel["LINK"].c_str(),
channel["DESCRIPTION"].c_str(),
str_image.c_str(),
etag.c_str(),
modified.c_str(),
feed["fid"].c_str() );
}
set_page_message( "There is new syndicated content from " + feed["title"] );
break;
}
result["error"] = "feed not parseable";
default:
set_page_message( "The feed from "+feed["title"]+" seems to be broken, because of error \""+result["response_code"]+"\". "+ result["error"] );
}
}
bool aggregator_parse_feed( string data, map <string, string> &feed )
{
channel.clear();
image.clear();
items.clear();
item = 0;
XML_Parser xml_parser = my_xml_parser_create( data );
XML_SetUserData(xml_parser, &xml_parser);
XML_SetElementHandler(xml_parser, aggregator_element_start, aggregator_element_end);
XML_SetCharacterDataHandler(xml_parser, aggregator_element_data);
if( !XML_Parse(xml_parser, data.c_str(), (int) data.length(), 1) )
{
string error = "The feed from "+feed["title"]+" seems to be broken, because of error " +
XML_ErrorString( XML_GetErrorCode( xml_parser ) ) + " on line " +
str( XML_GetCurrentLineNumber( xml_parser ) ) + ".";
set_page_message( error, "error");
return false;
}
XML_ParserFree(xml_parser);
for( int i = item; i>=0; i-- )
{
string title, link, guid, date;
for( map <string, string>::iterator curr = items[i].begin(), end = items[i].end(); curr != end; curr++ )
{
trim( curr->second );
items[i][curr->first] = curr->second;
}
// Resolve the item's title. If no title is found, we use up to 40
// characters of the description ending at a word boundary but not
// splitting potential entities.
if (isset(items[i]["TITLE"]))
{
title = items[i]["TITLE"];
}
else if (isset(items[i]["DESCRIPTION"]))
{
title = items[i]["DESCRIPTION"].substr(0, 40);
}
else
{
title = "";
}
// Resolve the items link.
if (isset(items[i]["LINK"]))
{
link = items[i]["LINK"];
}
else
{
link = feed["link"];
}
guid = isset(items[i]["GUID"]) ? items[i]["GUID"] : "";
// Atom feeds have a CONTENT and/or SUMMARY tag instead of a DESCRIPTION tag.
if (isset(items[i]["CONTENT:ENCODED"])) {
items[i]["DESCRIPTION"] = items[i]["CONTENT:ENCODED"];
}
else if (isset(items[i]["SUMMARY"])) {
items[i]["DESCRIPTION"] = items[i]["SUMMARY"];
}
else if (isset(items[i]["CONTENT"])) {
items[i]["DESCRIPTION"] = items[i]["CONTENT"];
}
if (isset(items[i]["DC:CREATOR"])) {
items[i]["AUTHOR"] = items[i]["DC:CREATOR"];
}
// Try to resolve and parse the item's publication date. If no date is
// found, we use the current date instead.
date = "now";
if (isset(items[i]["PUBDATE"])) { date = items[i]["PUBDATE"]; }
if (isset(items[i]["DC:DATE"])) { date = items[i]["DC:DATE"]; }
if (isset(items[i]["DCTERMS:ISSUED"])) { date = items[i]["DCTERMS:ISSUED"]; }
if (isset(items[i]["DCTERMS:CREATED"])) { date = items[i]["DCTERMS:CREATED"]; }
if (isset(items[i]["DCTERMS:MODIFIED"])) { date = items[i]["DCTERMS:MODIFIED"]; }
if (isset(items[i]["ISSUED"])) { date = items[i]["ISSUED"]; }
if (isset(items[i]["CREATED"])) { date = items[i]["CREATED"]; }
if (isset(items[i]["MODIFIED"])) { date = items[i]["MODIFIED"]; }
if (isset(items[i]["PUBLISHED"])) { date = items[i]["PUBLISHED"]; }
if (isset(items[i]["UPDATED"])) { date = items[i]["UPDATED"]; }
string timestamp = strtotime( date );
if( timestamp == "") timestamp = str( time() );
map <string, string> entry;
if(DB_TYPE==1)
{
if( isset( guid ) )
{
map <string, string> item;
REDIS_RES *result = redis_query_fields( redis_arg("SORT aggregator_item:fid:%d BY nosort", intval(feed["fid"])), "GET aggregator_item:*->", "#iid,guid");
while( redis_fetch_fields( result, item ) ) {
if( item["guid"] == guid) {
redis_free(result);
entry["iid"] = item["iid"];
break;
}
}
}
else if (isset(link) && link != feed["link"] && link != feed["url"])
{
map <string, string> item;
REDIS_RES *result = redis_query_fields( redis_arg("SORT aggregator_item:fid:%d BY nosort", intval(feed["fid"])), "GET aggregator_item:*->", "#iid,link");
while( redis_fetch_fields( result, item ) ) {
if( entry["link"] == link) {
redis_free(result);
entry["iid"] = item["iid"];
break;
}
}
}
else
{
map <string, string> item;
REDIS_RES *result = redis_query_fields( redis_arg("SORT aggregator_item:fid:%d BY nosort", intval(feed["fid"])), "GET aggregator_item:*->", "#iid,title");
while( redis_fetch_fields( result, item ) ) {
if( entry["title"] == title) {
redis_free(result);
entry["iid"] = item["iid"];
break;
}
}
}
}
if(DB_TYPE==2)
{
if( isset( guid ) )
{
db_fetch(db_querya("SELECT iid FROM aggregator_item WHERE fid = %d AND guid = '%s'", feed["fid"].c_str(), guid.c_str()), entry );
}
else if (isset(link) && link != feed["link"] && link != feed["url"])
{
db_fetch(db_querya("SELECT iid FROM aggregator_item WHERE fid = %d AND link = '%s'", feed["fid"].c_str(), link.c_str()), entry );
}
else {
db_fetch(db_querya("SELECT iid FROM aggregator_item WHERE fid = %d AND title = '%s'", feed["fid"].c_str(), title.c_str()), entry );
}
}
entry["fid"] = feed["fid"];
entry["livetime"] = feed["livetime"];
entry["timestamp"] = timestamp;
entry["title"] = title;
entry["link"] = link;
entry["author"] = items[i]["AUTHOR"];
entry["description"] = items[i]["DESCRIPTION"];
entry["guid"] = guid;
aggregator_save_item( entry );
}
// Remove all items that are older than flush item timer.
if(DB_TYPE==1)
{
}
if(DB_TYPE==2)
{
db_querya("DELETE FROM aggregator_item WHERE fid = %d AND livetime>0 AND timestamp < unix_timestamp()-livetime", feed["fid"].c_str() );
}
return true;
}
int
main(int argc, char **argv) {
isc_result_t result;
#ifdef USE_PKCS11
const char *engine = "pkcs11";
#else
const char *engine = NULL;
#endif
char *filename = NULL, *directory = NULL;
char newname[1024];
char keystr[DST_KEY_FORMATSIZE];
char *endp, *p;
int ch;
isc_entropy_t *ectx = NULL;
const char *predecessor = NULL;
dst_key_t *prevkey = NULL;
dst_key_t *key = NULL;
isc_buffer_t buf;
dns_name_t *name = NULL;
dns_secalg_t alg = 0;
unsigned int size = 0;
isc_uint16_t flags = 0;
int prepub = -1;
dns_ttl_t ttl = 0;
isc_stdtime_t now;
isc_stdtime_t pub = 0, act = 0, rev = 0, inact = 0, del = 0;
isc_boolean_t setpub = ISC_FALSE, setact = ISC_FALSE;
isc_boolean_t setrev = ISC_FALSE, setinact = ISC_FALSE;
isc_boolean_t setdel = ISC_FALSE, setttl = ISC_FALSE;
isc_boolean_t unsetpub = ISC_FALSE, unsetact = ISC_FALSE;
isc_boolean_t unsetrev = ISC_FALSE, unsetinact = ISC_FALSE;
isc_boolean_t unsetdel = ISC_FALSE;
isc_boolean_t printcreate = ISC_FALSE, printpub = ISC_FALSE;
isc_boolean_t printact = ISC_FALSE, printrev = ISC_FALSE;
isc_boolean_t printinact = ISC_FALSE, printdel = ISC_FALSE;
isc_boolean_t force = ISC_FALSE;
isc_boolean_t epoch = ISC_FALSE;
isc_boolean_t changed = ISC_FALSE;
isc_log_t *log = NULL;
isc__mem_register();
if (argc == 1)
usage();
result = isc_mem_create(0, 0, &mctx);
if (result != ISC_R_SUCCESS)
fatal("Out of memory");
setup_logging(verbose, mctx, &log);
dns_result_register();
isc_commandline_errprint = ISC_FALSE;
isc_stdtime_get(&now);
#define CMDLINE_FLAGS "A:D:E:fhI:i:K:L:P:p:R:S:uv:"
while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) {
switch (ch) {
case 'E':
engine = isc_commandline_argument;
break;
case 'f':
force = ISC_TRUE;
break;
case 'p':
p = isc_commandline_argument;
if (!strcasecmp(p, "all")) {
printcreate = ISC_TRUE;
printpub = ISC_TRUE;
printact = ISC_TRUE;
printrev = ISC_TRUE;
printinact = ISC_TRUE;
printdel = ISC_TRUE;
break;
}
do {
switch (*p++) {
case 'C':
printcreate = ISC_TRUE;
break;
case 'P':
printpub = ISC_TRUE;
break;
case 'A':
printact = ISC_TRUE;
break;
case 'R':
printrev = ISC_TRUE;
break;
case 'I':
printinact = ISC_TRUE;
break;
case 'D':
printdel = ISC_TRUE;
break;
case ' ':
break;
default:
usage();
break;
}
} while (*p != '\0');
break;
case 'u':
epoch = ISC_TRUE;
break;
case 'K':
/*
* We don't have to copy it here, but do it to
* simplify cleanup later
*/
directory = isc_mem_strdup(mctx,
isc_commandline_argument);
if (directory == NULL) {
fatal("Failed to allocate memory for "
"directory");
}
break;
case 'L':
if (strcmp(isc_commandline_argument, "none") == 0)
ttl = 0;
else
ttl = strtottl(isc_commandline_argument);
setttl = ISC_TRUE;
break;
case 'v':
verbose = strtol(isc_commandline_argument, &endp, 0);
if (*endp != '\0')
fatal("-v must be followed by a number");
break;
case 'P':
if (setpub || unsetpub)
fatal("-P specified more than once");
changed = ISC_TRUE;
if (!strcasecmp(isc_commandline_argument, "none")) {
unsetpub = ISC_TRUE;
} else {
setpub = ISC_TRUE;
pub = strtotime(isc_commandline_argument,
now, now);
}
break;
case 'A':
if (setact || unsetact)
fatal("-A specified more than once");
changed = ISC_TRUE;
if (!strcasecmp(isc_commandline_argument, "none")) {
unsetact = ISC_TRUE;
} else {
setact = ISC_TRUE;
act = strtotime(isc_commandline_argument,
now, now);
}
break;
case 'R':
if (setrev || unsetrev)
fatal("-R specified more than once");
changed = ISC_TRUE;
if (!strcasecmp(isc_commandline_argument, "none")) {
unsetrev = ISC_TRUE;
} else {
setrev = ISC_TRUE;
rev = strtotime(isc_commandline_argument,
now, now);
}
break;
case 'I':
if (setinact || unsetinact)
fatal("-I specified more than once");
changed = ISC_TRUE;
if (!strcasecmp(isc_commandline_argument, "none")) {
unsetinact = ISC_TRUE;
} else {
setinact = ISC_TRUE;
inact = strtotime(isc_commandline_argument,
now, now);
}
break;
case 'D':
if (setdel || unsetdel)
fatal("-D specified more than once");
changed = ISC_TRUE;
if (!strcasecmp(isc_commandline_argument, "none")) {
unsetdel = ISC_TRUE;
} else {
setdel = ISC_TRUE;
del = strtotime(isc_commandline_argument,
now, now);
}
break;
case 'S':
predecessor = isc_commandline_argument;
break;
case 'i':
prepub = strtottl(isc_commandline_argument);
break;
case '?':
if (isc_commandline_option != '?')
fprintf(stderr, "%s: invalid argument -%c\n",
program, isc_commandline_option);
/* Falls into */
case 'h':
usage();
default:
fprintf(stderr, "%s: unhandled option -%c\n",
program, isc_commandline_option);
exit(1);
}
}
if (argc < isc_commandline_index + 1 ||
argv[isc_commandline_index] == NULL)
fatal("The key file name was not specified");
if (argc > isc_commandline_index + 1)
fatal("Extraneous arguments");
if (ectx == NULL)
setup_entropy(mctx, NULL, &ectx);
result = isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE);
if (result != ISC_R_SUCCESS)
fatal("Could not initialize hash");
result = dst_lib_init2(mctx, ectx, engine,
ISC_ENTROPY_BLOCKING | ISC_ENTROPY_GOODONLY);
if (result != ISC_R_SUCCESS)
fatal("Could not initialize dst: %s",
isc_result_totext(result));
isc_entropy_stopcallbacksources(ectx);
if (predecessor != NULL) {
char keystr[DST_KEY_FORMATSIZE];
isc_stdtime_t when;
int major, minor;
if (prepub == -1)
prepub = (30 * 86400);
if (setpub || unsetpub)
fatal("-S and -P cannot be used together");
if (setact || unsetact)
fatal("-S and -A cannot be used together");
result = dst_key_fromnamedfile(predecessor, directory,
DST_TYPE_PUBLIC |
DST_TYPE_PRIVATE,
mctx, &prevkey);
if (result != ISC_R_SUCCESS)
fatal("Invalid keyfile %s: %s",
filename, isc_result_totext(result));
if (!dst_key_isprivate(prevkey))
fatal("%s is not a private key", filename);
name = dst_key_name(prevkey);
alg = dst_key_alg(prevkey);
size = dst_key_size(prevkey);
flags = dst_key_flags(prevkey);
dst_key_format(prevkey, keystr, sizeof(keystr));
dst_key_getprivateformat(prevkey, &major, &minor);
if (major != DST_MAJOR_VERSION || minor < DST_MINOR_VERSION)
fatal("Predecessor has incompatible format "
"version %d.%d\n\t", major, minor);
result = dst_key_gettime(prevkey, DST_TIME_ACTIVATE, &when);
if (result != ISC_R_SUCCESS)
fatal("Predecessor has no activation date. "
"You must set one before\n\t"
"generating a successor.");
result = dst_key_gettime(prevkey, DST_TIME_INACTIVE, &act);
if (result != ISC_R_SUCCESS)
fatal("Predecessor has no inactivation date. "
"You must set one before\n\t"
"generating a successor.");
pub = act - prepub;
if (pub < now && prepub != 0)
fatal("Predecessor will become inactive before the\n\t"
"prepublication period ends. Either change "
"its inactivation date,\n\t"
"or use the -i option to set a shorter "
"prepublication interval.");
result = dst_key_gettime(prevkey, DST_TIME_DELETE, &when);
if (result != ISC_R_SUCCESS)
fprintf(stderr, "%s: WARNING: Predecessor has no "
"removal date;\n\t"
"it will remain in the zone "
"indefinitely after rollover.\n",
program);
changed = setpub = setact = ISC_TRUE;
dst_key_free(&prevkey);
} else {
if (prepub < 0)
prepub = 0;
if (prepub > 0) {
if (setpub && setact && (act - prepub) < pub)
fatal("Activation and publication dates "
"are closer together than the\n\t"
"prepublication interval.");
if (setpub && !setact) {
setact = ISC_TRUE;
act = pub + prepub;
} else if (setact && !setpub) {
setpub = ISC_TRUE;
pub = act - prepub;
}
if ((act - prepub) < now)
fatal("Time until activation is shorter "
"than the\n\tprepublication interval.");
}
}
if (directory != NULL) {
filename = argv[isc_commandline_index];
} else {
result = isc_file_splitpath(mctx, argv[isc_commandline_index],
&directory, &filename);
if (result != ISC_R_SUCCESS)
fatal("cannot process filename %s: %s",
argv[isc_commandline_index],
isc_result_totext(result));
}
result = dst_key_fromnamedfile(filename, directory,
DST_TYPE_PUBLIC | DST_TYPE_PRIVATE,
mctx, &key);
if (result != ISC_R_SUCCESS)
fatal("Invalid keyfile %s: %s",
filename, isc_result_totext(result));
if (!dst_key_isprivate(key))
fatal("%s is not a private key", filename);
dst_key_format(key, keystr, sizeof(keystr));
if (predecessor != NULL) {
if (!dns_name_equal(name, dst_key_name(key)))
fatal("Key name mismatch");
if (alg != dst_key_alg(key))
fatal("Key algorithm mismatch");
if (size != dst_key_size(key))
fatal("Key size mismatch");
if (flags != dst_key_flags(key))
fatal("Key flags mismatch");
}
if (force)
set_keyversion(key);
else
check_keyversion(key, keystr);
if (verbose > 2)
fprintf(stderr, "%s: %s\n", program, keystr);
/*
* Set time values.
*/
if (setpub)
dst_key_settime(key, DST_TIME_PUBLISH, pub);
else if (unsetpub)
dst_key_unsettime(key, DST_TIME_PUBLISH);
if (setact)
dst_key_settime(key, DST_TIME_ACTIVATE, act);
else if (unsetact)
dst_key_unsettime(key, DST_TIME_ACTIVATE);
if (setrev) {
if ((dst_key_flags(key) & DNS_KEYFLAG_REVOKE) != 0)
fprintf(stderr, "%s: warning: Key %s is already "
"revoked; changing the revocation date "
"will not affect this.\n",
program, keystr);
if ((dst_key_flags(key) & DNS_KEYFLAG_KSK) == 0)
fprintf(stderr, "%s: warning: Key %s is not flagged as "
"a KSK, but -R was used. Revoking a "
"ZSK is legal, but undefined.\n",
program, keystr);
dst_key_settime(key, DST_TIME_REVOKE, rev);
} else if (unsetrev) {
if ((dst_key_flags(key) & DNS_KEYFLAG_REVOKE) != 0)
fprintf(stderr, "%s: warning: Key %s is already "
"revoked; removing the revocation date "
"will not affect this.\n",
program, keystr);
dst_key_unsettime(key, DST_TIME_REVOKE);
}
if (setinact)
dst_key_settime(key, DST_TIME_INACTIVE, inact);
else if (unsetinact)
dst_key_unsettime(key, DST_TIME_INACTIVE);
if (setdel)
dst_key_settime(key, DST_TIME_DELETE, del);
else if (unsetdel)
dst_key_unsettime(key, DST_TIME_DELETE);
if (setttl)
dst_key_setttl(key, ttl);
/*
* No metadata changes were made but we're forcing an upgrade
* to the new format anyway: use "-P now -A now" as the default
*/
if (force && !changed) {
dst_key_settime(key, DST_TIME_PUBLISH, now);
dst_key_settime(key, DST_TIME_ACTIVATE, now);
changed = ISC_TRUE;
}
if (!changed && setttl)
changed = ISC_TRUE;
/*
* Print out time values, if -p was used.
*/
if (printcreate)
printtime(key, DST_TIME_CREATED, "Created", epoch, stdout);
if (printpub)
printtime(key, DST_TIME_PUBLISH, "Publish", epoch, stdout);
if (printact)
printtime(key, DST_TIME_ACTIVATE, "Activate", epoch, stdout);
if (printrev)
printtime(key, DST_TIME_REVOKE, "Revoke", epoch, stdout);
if (printinact)
printtime(key, DST_TIME_INACTIVE, "Inactive", epoch, stdout);
if (printdel)
printtime(key, DST_TIME_DELETE, "Delete", epoch, stdout);
if (changed) {
isc_buffer_init(&buf, newname, sizeof(newname));
result = dst_key_buildfilename(key, DST_TYPE_PUBLIC, directory,
&buf);
if (result != ISC_R_SUCCESS) {
fatal("Failed to build public key filename: %s",
isc_result_totext(result));
}
result = dst_key_tofile(key, DST_TYPE_PUBLIC|DST_TYPE_PRIVATE,
directory);
if (result != ISC_R_SUCCESS) {
dst_key_format(key, keystr, sizeof(keystr));
fatal("Failed to write key %s: %s", keystr,
isc_result_totext(result));
}
printf("%s\n", newname);
isc_buffer_clear(&buf);
result = dst_key_buildfilename(key, DST_TYPE_PRIVATE, directory,
&buf);
if (result != ISC_R_SUCCESS) {
fatal("Failed to build private key filename: %s",
isc_result_totext(result));
}
printf("%s\n", newname);
}
dst_key_free(&key);
dst_lib_destroy();
isc_hash_destroy();
cleanup_entropy(&ectx);
if (verbose > 10)
isc_mem_stats(mctx, stdout);
cleanup_logging(&log);
isc_mem_free(mctx, directory);
isc_mem_destroy(&mctx);
return (0);
}
int msgq::queuescan3(std::string subdir, std::string name,
const char *isnewmsg)
{
struct ctlfile ctlinfo;
ino_t inum;
time_t deltime, delsendtime;
const char *p=name.c_str();
struct stat stat_buf;
++p;
inum=strtoino(p);
while (isdigit(*p)) p++;
++p;
deltime=strtotime(p);
name= subdir + '/' + name;
if (ctlfile_openfn(name.c_str(), &ctlinfo, 0, 1))
{
if (errno)
{
clog_msg_start_err();
clog_msg_str("Cannot read ");
clog_msg_str(name.c_str());
clog_msg_send();
clog_msg_prerrno();
}
return (0);
}
delsendtime=deltime;
if (flushtime && ctlinfo.mtime < flushtime && flushtime < deltime)
delsendtime=flushtime;
if (!queuefree)
{
msgq *p;
//
// msgq array is full. See if we can remove the last message from the
// pending queue.
p=queuetail;
if (p && p->nextsenddel > delsendtime)
{
#if 0
clog_msg_start_info();
clog_msg_str("Removing ");
clog_msg_uint(p->msgnum);
clog_msg_str(" to make room for this message.");
clog_msg_send();
#endif
p->removewq();
p->removeq();
}
}
msgq *newq=queuefree;
if (!newq)
{
ctlfile_close(&ctlinfo);
if (queuefill && nextqueuefill == 0)
{
nextqueuefill=current_time + queuefill;
}
return (1);
}
const char *cn=qmsgsctlname(inum);
if ( stat(cn, &stat_buf) == -1 )
{
unlink(name.c_str());
unlink(qmsgsdatname(inum));
unlink(cn);
ctlfile_close(&ctlinfo);
return (0);
}
#if 0
clog_msg_start_info();
clog_msg_str("Adding ");
clog_msg_uint(inum);
clog_msg_str(" to queue.");
clog_msg_send();
#endif
queuefree=newq->next;
++queuedelivering;
ino_t hashbucket=inum % queuehashfirst.size();
if (queuehashfirst[hashbucket])
queuehashfirst[hashbucket]->prevhash=newq;
else
queuehashlast[hashbucket]=newq;
newq->nexthash=queuehashfirst[hashbucket];
newq->prevhash=0;
queuehashfirst[hashbucket]=newq;
newq->nksize= (unsigned long)stat_buf.st_size;
ctlinfo.starttime=stat_buf.st_mtime;
int k=ctlfile_searchfirst(&ctlinfo, COMCTLFILE_MSGID);
newq->msgid= k < 0 ? "": ctlinfo.lines[k]+1;
newq->msgnum=inum;
newq->nextdel=deltime;
newq->nextsenddel=delsendtime;
newq->rcptinfo_list.resize(0);
newq->rcptcount=0;
newq->cancelled=ctlinfo.cancelled;
if (isnewmsg)
{
int auth;
clog_msg_start_info();
clog_msg_str("newmsg,id=");
logmsgid(newq);
auth=ctlfile_searchfirst(&ctlinfo, COMCTLFILE_AUTHNAME);
if (auth >= 0)
{
clog_msg_str(", auth=");
clog_msg_str(ctlinfo.lines[auth]+1);
}
int m=ctlfile_searchfirst(&ctlinfo, COMCTLFILE_FROMMTA);
if (m >= 0)
{
clog_msg_str(": ");
clog_msg_str(ctlinfo.lines[m]+1);
}
clog_msg_send();
}
unsigned i, j;
std::string host, addr;
k=ctlfile_searchfirst(&ctlinfo, COMCTLFILE_SENDER);
struct rfc822t *sendert=rw_rewrite_tokenize(k < 0 ? "":ctlinfo.lines[k]+1);
std::string errmsg;
for (i=0; i<ctlinfo.nreceipients; i++)
{
for (j=0; ctlinfo.lines[j]; j++)
{
switch (ctlinfo.lines[j][0]) {
case COMCTLFILE_DELSUCCESS:
case COMCTLFILE_DELFAIL:
if ((unsigned)atoi(ctlinfo.lines[j]+1) == i)
break;
// This one has been delivered
default:
continue;
}
break;
}
if (ctlinfo.lines[j]) continue;
drvinfo *module=getdelinfo(sendert->tokens,
ctlinfo.receipients[i], host, addr, errmsg);
if (!module)
{
ctlfile_append_reply(&ctlinfo, i, errmsg.c_str(),
SMTPREPLY_TYPE(errmsg.c_str()),
0);
continue;
}
/* Check if it's time to move the message to a backup relay */
if (backup_relay_driver &&
ctlfile_searchfirst(&ctlinfo, COMCTLFILE_WARNINGSENT)
>= 0 &&
strcmp(module->module->name,
backup_relay_driver->module->name) == 0)
{
// module=backup_relay_driver;
host=backup_relay;
}
/* Group all recipients for the same driver and host together */
for (j=0; j<newq->rcptcount; j++)
if (strcmp(module->module->name,
newq->rcptinfo_list[j].delmodule->
module->name) == 0 &&
newq->rcptinfo_list[j].delhost == host &&
newq->rcptinfo_list[j].addresses.size()
< module->maxrcpt )
break;
if (j == newq->rcptcount)
{
#if 0
clog_msg_start_info();
clog_msg_str("id=");
logmsgid(newq);
clog_msg_str(",new rcpt list - module=");
clog_msg_str(module->module->name);
clog_msg_str(", host=");
clog_msg_str(host);
clog_msg_send();
#endif
newq->rcptinfo_list.resize(++newq->rcptcount);
struct rw_info_rewrite rwir;
struct rw_info rwi;
rwir.buf=0;
rwir.errmsg=0;
rw_info_init(&rwi, sendert->tokens, rw_err_func);
rwi.sender=0;
rwi.mode=RW_OUTPUT|RW_ENVSENDER;
rwi.udata= (void *)&rwir;
rw_rewrite_module(module->module, &rwi,
rw_rewrite_chksyn_print);
char *address=((struct rw_info_rewrite *)rwi.udata)->buf;
char *errmsg= ((struct rw_info_rewrite *)rwi.udata)->errmsg;
if (!address)
{
ctlfile_append_reply(&ctlinfo, i, errmsg,
SMTPREPLY_TYPE(errmsg), 0);
newq->rcptinfo_list.resize(--newq->rcptcount);
free(errmsg);
continue;
}
if (errmsg) free(errmsg);
newq->rcptinfo_list[j].init(newq, module, host, address);
free(address);
}
#if 0
clog_msg_start_info();
clog_msg_str("id=");
logmsgid(newq);
clog_msg_str(",module=");
clog_msg_str(module->module->name);
clog_msg_str(", host=");
clog_msg_str(host);
clog_msg_str(", addr=<");
clog_msg_str(addr);
clog_msg_str(">");
clog_msg_send();
#endif
newq->rcptinfo_list[j].addresses.push_back(addr);
newq->rcptinfo_list[j].addressesidx.push_back(i);
}
rfc822t_free(sendert);
ctlfile_close(&ctlinfo);
if (newq->nextsenddel <= current_time ||
/*
** If there are no more recipients, we want to call done() via
** start_message. HOWEVER, if DSN injection FAILED, we want to respect
** the rescheduled delivery attempt time. We can detect that if isnewmsg == 0
*/
(newq->rcptinfo_list.size() == 0 && isnewmsg))
{
newq->start_message();
return (0);
}
msgq *qp, *qprev;
for (qprev=queuetail, qp=0; qprev; qp=qprev, qprev=qp->prev)
if (qprev->nextsenddel < newq->nextsenddel)
break;
newq->next=qp;
newq->prev=qprev;
if (qprev) qprev->next=newq;
else queuehead=newq;
if (qp) qp->prev=newq;
else queuetail=newq;
++queuewaiting;
return (0);
}
void msgq::queuescan()
{
static int queuescan_flag=0;
if (queuescan_flag) return;
// Recursive invocation if message just pulled into queue
// has been delivered to all of its recipients.
nextqueuefill=0;
#if 0
clog_msg_start_info();
clog_msg_str("queue scan");
clog_msg_send();
#endif
try
{
std::list<std::string> subdirlist;
DIR *tmpdir=opendir(MSGQDIR);
struct dirent *de;
std::string s;
queuescan_flag=1;
if (!tmpdir) clog_msg_errno();
time(¤t_time);
while ((de=readdir(tmpdir)) != 0)
{
const char *p;
for (p=de->d_name; *p; p++)
if (!isdigit((int)(unsigned char)*p)) break;
if (*p) continue; // Subdirs must be named all digits
p=de->d_name;
time_t n=strtotime(p);
std::list<std::string>::iterator sb, se;
sb=subdirlist.begin();
se=subdirlist.end();
while (sb != se)
{
if (strtotime(sb->c_str()) > n)
break;
++sb;
}
subdirlist.insert(sb, de->d_name);
}
closedir(tmpdir);
while (!subdirlist.empty())
{
s=MSGQDIR "/";
s += subdirlist.front();
subdirlist.pop_front();
if (queuescan2(s) <= 0) break;
// Stop if we can't add any more msgs
}
queuescan_flag=0;
}
catch (...)
{
queuescan_flag=0;
throw;
}
}
int
main(int argc, char *argv[]) {
int i, ch;
char *startstr = NULL, *endstr = NULL;
dns_fixedname_t fdomain;
dns_name_t *domain = NULL;
char *output = NULL;
char *endp;
unsigned char data[65536];
dns_db_t *db;
dns_dbversion_t *version;
dns_diff_t diff;
dns_difftuple_t *tuple;
dns_fixedname_t tname;
dst_key_t *key = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_t rdataset;
dns_rdataclass_t rdclass;
isc_result_t result;
isc_buffer_t b;
isc_region_t r;
isc_log_t *log = NULL;
keynode_t *keynode;
unsigned int eflags;
isc_boolean_t pseudorandom = ISC_FALSE;
isc_boolean_t tryverify = ISC_FALSE;
result = isc_mem_create(0, 0, &mctx);
if (result != ISC_R_SUCCESS)
fatal("failed to create memory context: %s",
isc_result_totext(result));
dns_result_register();
while ((ch = isc_commandline_parse(argc, argv, "as:e:t:r:v:ph")) != -1)
{
switch (ch) {
case 'a':
tryverify = ISC_TRUE;
break;
case 's':
startstr = isc_commandline_argument;
break;
case 'e':
endstr = isc_commandline_argument;
break;
case 't':
endp = NULL;
ttl = strtol(isc_commandline_argument, &endp, 0);
if (*endp != '\0')
fatal("TTL must be numeric");
break;
case 'r':
setup_entropy(mctx, isc_commandline_argument, &ectx);
break;
case 'v':
endp = NULL;
verbose = strtol(isc_commandline_argument, &endp, 0);
if (*endp != '\0')
fatal("verbose level must be numeric");
break;
case 'p':
pseudorandom = ISC_TRUE;
break;
case 'h':
default:
usage();
}
}
argc -= isc_commandline_index;
argv += isc_commandline_index;
if (argc < 1)
usage();
if (ectx == NULL)
setup_entropy(mctx, NULL, &ectx);
eflags = ISC_ENTROPY_BLOCKING;
if (!pseudorandom)
eflags |= ISC_ENTROPY_GOODONLY;
result = dst_lib_init(mctx, ectx, eflags);
if (result != ISC_R_SUCCESS)
fatal("could not initialize dst: %s",
isc_result_totext(result));
isc_stdtime_get(&now);
if (startstr != NULL)
starttime = strtotime(startstr, now, now);
else
starttime = now;
if (endstr != NULL)
endtime = strtotime(endstr, now, starttime);
else
endtime = starttime + (30 * 24 * 60 * 60);
if (ttl == -1) {
ttl = 3600;
fprintf(stderr, "%s: TTL not specified, assuming 3600\n",
program);
}
setup_logging(verbose, mctx, &log);
dns_diff_init(mctx, &diff);
rdclass = 0;
ISC_LIST_INIT(keylist);
for (i = 0; i < argc; i++) {
char namestr[DNS_NAME_FORMATSIZE];
isc_buffer_t namebuf;
key = NULL;
result = dst_key_fromnamedfile(argv[i], DST_TYPE_PUBLIC,
mctx, &key);
if (result != ISC_R_SUCCESS)
fatal("error loading key from %s: %s", argv[i],
isc_result_totext(result));
if (rdclass == 0)
rdclass = dst_key_class(key);
isc_buffer_init(&namebuf, namestr, sizeof(namestr));
result = dns_name_tofilenametext(dst_key_name(key),
ISC_FALSE,
&namebuf);
check_result(result, "dns_name_tofilenametext");
isc_buffer_putuint8(&namebuf, 0);
if (domain == NULL) {
dns_fixedname_init(&fdomain);
domain = dns_fixedname_name(&fdomain);
dns_name_copy(dst_key_name(key), domain, NULL);
} else if (!dns_name_equal(domain, dst_key_name(key))) {
char str[DNS_NAME_FORMATSIZE];
dns_name_format(domain, str, sizeof(str));
fatal("all keys must have the same owner - %s "
"and %s do not match", str, namestr);
}
if (output == NULL) {
output = isc_mem_allocate(mctx,
strlen("keyset-") +
strlen(namestr) + 1);
if (output == NULL)
fatal("out of memory");
sprintf(output, "keyset-%s", namestr);
}
if (dst_key_iszonekey(key)) {
dst_key_t *zonekey = NULL;
result = dst_key_fromnamedfile(argv[i],
DST_TYPE_PUBLIC |
DST_TYPE_PRIVATE,
mctx, &zonekey);
if (result != ISC_R_SUCCESS)
fatal("failed to read private key %s: %s",
argv[i], isc_result_totext(result));
if (!zonekey_on_list(zonekey)) {
keynode = isc_mem_get(mctx, sizeof(keynode_t));
if (keynode == NULL)
fatal("out of memory");
keynode->key = zonekey;
ISC_LIST_INITANDAPPEND(keylist, keynode, link);
} else
dst_key_free(&zonekey);
}
dns_rdata_reset(&rdata);
isc_buffer_init(&b, data, sizeof(data));
result = dst_key_todns(key, &b);
dst_key_free(&key);
if (result != ISC_R_SUCCESS)
fatal("failed to convert key %s to a DNS KEY: %s",
argv[i], isc_result_totext(result));
isc_buffer_usedregion(&b, &r);
dns_rdata_fromregion(&rdata, rdclass, dns_rdatatype_dnskey, &r);
tuple = NULL;
result = dns_difftuple_create(mctx, DNS_DIFFOP_ADD,
domain, ttl, &rdata, &tuple);
check_result(result, "dns_difftuple_create");
dns_diff_append(&diff, &tuple);
}
db = NULL;
result = dns_db_create(mctx, "rbt", dns_rootname, dns_dbtype_zone,
rdclass, 0, NULL, &db);
if (result != ISC_R_SUCCESS)
fatal("failed to create a database");
version = NULL;
dns_db_newversion(db, &version);
result = dns_diff_apply(&diff, db, version);
check_result(result, "dns_diff_apply");
dns_diff_clear(&diff);
dns_fixedname_init(&tname);
dns_rdataset_init(&rdataset);
result = dns_db_find(db, domain, version, dns_rdatatype_dnskey, 0, 0,
NULL, dns_fixedname_name(&tname), &rdataset,
NULL);
check_result(result, "dns_db_find");
if (ISC_LIST_EMPTY(keylist))
fprintf(stderr,
"%s: no private zone key found; not self-signing\n",
program);
for (keynode = ISC_LIST_HEAD(keylist);
keynode != NULL;
keynode = ISC_LIST_NEXT(keynode, link))
{
dns_rdata_reset(&rdata);
isc_buffer_init(&b, data, sizeof(data));
result = dns_dnssec_sign(domain, &rdataset, keynode->key,
&starttime, &endtime, mctx, &b,
&rdata);
isc_entropy_stopcallbacksources(ectx);
if (result != ISC_R_SUCCESS) {
char keystr[KEY_FORMATSIZE];
key_format(keynode->key, keystr, sizeof(keystr));
fatal("failed to sign keyset with key %s: %s",
keystr, isc_result_totext(result));
}
if (tryverify) {
result = dns_dnssec_verify(domain, &rdataset,
keynode->key, ISC_TRUE,
mctx, &rdata);
if (result != ISC_R_SUCCESS) {
char keystr[KEY_FORMATSIZE];
key_format(keynode->key, keystr, sizeof(keystr));
fatal("signature from key '%s' failed to "
"verify: %s",
keystr, isc_result_totext(result));
}
}
tuple = NULL;
result = dns_difftuple_create(mctx, DNS_DIFFOP_ADD,
domain, ttl, &rdata, &tuple);
check_result(result, "dns_difftuple_create");
dns_diff_append(&diff, &tuple);
}
result = dns_diff_apply(&diff, db, version);
check_result(result, "dns_diff_apply");
dns_diff_clear(&diff);
dns_rdataset_disassociate(&rdataset);
dns_db_closeversion(db, &version, ISC_TRUE);
result = dns_db_dump(db, version, output);
if (result != ISC_R_SUCCESS) {
char domainstr[DNS_NAME_FORMATSIZE];
dns_name_format(domain, domainstr, sizeof(domainstr));
fatal("failed to write database for %s to %s",
domainstr, output);
}
printf("%s\n", output);
dns_db_detach(&db);
while (!ISC_LIST_EMPTY(keylist)) {
keynode = ISC_LIST_HEAD(keylist);
ISC_LIST_UNLINK(keylist, keynode, link);
dst_key_free(&keynode->key);
isc_mem_put(mctx, keynode, sizeof(keynode_t));
}
cleanup_logging(&log);
cleanup_entropy(&ectx);
isc_mem_free(mctx, output);
dst_lib_destroy();
if (verbose > 10)
isc_mem_stats(mctx, stdout);
isc_mem_destroy(&mctx);
return (0);
}
int ndisk_dir(Dictionary *dict, const NDiskEntry *entry, NDisk *disk, const wchar_t *path) {
WIN32_FIND_DATAW fData;
char *tmp = NULL, *sTmp = NULL;
wchar_t *pTmp = NULL;
unsigned long size = 0;
int i = 0;
SYSTEMTIME time;
lua_reset();
lua_getglobal(script, "entries");
tmp = wtoc(entry->name);
lua_getfield(script, -1, tmp);
free(tmp);
tmp = NULL;
i = lua_gettop(script);
if(lua_pcall(script, 0, 0, 0)) {
OutputDebugStringA("Error Msg is: ");
OutputDebugStringA(lua_tostring(script, -1));
}
lua_pop(script, 1);
lua_getglobal(script, "dir");
if(!lua_isfunction(script, -1)) {
RequestProcW(PluginNumber, RT_MsgOK, L"ÅäÖôíÎó", L"ÍøÅ̽ű¾´íÎó, ²»ÄܶÁÈ¡µ±Ç°Ä¿Â¼µÄÄÚÈÝ. ", NULL, 0);
return NDISK_FATAL;
}
if(ndisk_lua_push(script, disk) == NDISK_FATAL) {
lua_settop(script, 0);
return NDISK_FATAL;
}
tmp = wtoc(path);
lua_pushstring(script, tmp);
free(tmp);
tmp = NULL;
lua_setfield(script, -2, "path");
if(lua_pcall(script, 1, 1, 0)) {
OutputDebugStringA("Error Msg is: ");
OutputDebugStringA(lua_tostring(script, -1));
}
if(lua_istable(script, -1)) {
lua_pushnil(script);
while (lua_next(script, -2)) {
if(lua_istable(script, -1)) {
memset(&fData, 0, sizeof(WIN32_FIND_DATAW));
lua_pushnil(script);
while(lua_next(script, -2)) {
tmp = (char *)lua_tostring(script, -2);
if(strcmp(tmp, "attribute") == 0) {
sTmp = (char *)lua_tostring(script, -1);
if(strcmp(sTmp, "file") == 0) {
fData.dwFileAttributes = FILE_ATTRIBUTE_NORMAL;
}
if(strcmp(sTmp, "directory") == 0) {
fData.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
}
}
if(strcmp(tmp, "filename") == 0) {
sTmp = (char *)lua_tostring(script, -1);
pTmp = ctow(sTmp);
wcslcpy(fData.cFileName, pTmp, PATH_MAX);
free(pTmp);
pTmp = NULL;
}
if(strcmp(tmp, "size") == 0) {
size = (unsigned long)lua_tonumber(script, -1);
fData.nFileSizeHigh = HIWORD(size);
fData.nFileSizeLow = LOWORD(size);
}
if(strcmp(tmp, "create") == 0) {
sTmp = (char *)lua_tostring(script, -1);
pTmp = ctow(sTmp);
memset(&time, 0, sizeof(SYSTEMTIME));
if(strtotime(pTmp, &time)) {
SystemTimeToFileTime(&time, &fData.ftCreationTime);
}
free(pTmp);
pTmp = NULL;
}
if(strcmp(tmp, "access") == 0) {
sTmp = (char *)lua_tostring(script, -1);
pTmp = ctow(sTmp);
memset(&time, 0, sizeof(SYSTEMTIME));
if(strtotime(pTmp, &time)) {
SystemTimeToFileTime(&time, &fData.ftLastAccessTime);
}
free(pTmp);
pTmp = NULL;
}
if(strcmp(tmp, "write") == 0) {
sTmp = (char *)lua_tostring(script, -1);
pTmp = ctow(sTmp);
memset(&time, 0, sizeof(SYSTEMTIME));
if(strtotime(pTmp, &time)) {
SystemTimeToFileTime(&time, &fData.ftLastWriteTime);
}
free(pTmp);
pTmp = NULL;
}
lua_pop(script, 1);
}
if(fData.cFileName) {
dict_set_element(dict, fData.cFileName, &fData, sizeof(WIN32_FIND_DATAW));
}
}
lua_pop(script, 1);
}
}
lua_pop(script, 1);
return NDISK_OK;
}