/*----------------------------------------------------------------------------*/
static int
uart_handler(unsigned char ch)
{
switch (state) {
case ST_AWAIT_CMD:
state = ch == CMD_CONFIG ? ST_AWAIT_DATA : ST_AWAIT_CMD;
break;
case ST_AWAIT_DATA:
if (ch == ASCII_EOT) {
log_i("UART: Received new configuration\n");
*buf_ptr = '\0';
parse_ini(app_config_buffer, &inga_conf_file);
app_config_update();
buf_ptr = app_config_buffer;
state = ST_AWAIT_CMD;
} else {
*(buf_ptr++) = ch;
}
break;
}
return 0;
}
static int process_include(const char *value, void *data,
const char *file, int linenum)
{
glob_t globbuf;
int globret, ret = 0;
size_t gindex;
struct section_t *section = data;
static const int config_max_recursion = 10;
if(value == NULL) {
pm_printf(ALPM_LOG_ERROR, _("config file %s, line %d: directive '%s' needs a value\n"),
file, linenum, "Include");
return 1;
}
if(section->depth >= config_max_recursion) {
pm_printf(ALPM_LOG_ERROR,
_("config parsing exceeded max recursion depth of %d.\n"),
config_max_recursion);
return 1;
}
section->depth++;
/* Ignore include failures... assume non-critical */
globret = glob(value, GLOB_NOCHECK, NULL, &globbuf);
switch(globret) {
case GLOB_NOSPACE:
pm_printf(ALPM_LOG_DEBUG,
"config file %s, line %d: include globbing out of space\n",
file, linenum);
break;
case GLOB_ABORTED:
pm_printf(ALPM_LOG_DEBUG,
"config file %s, line %d: include globbing read error for %s\n",
file, linenum, value);
break;
case GLOB_NOMATCH:
pm_printf(ALPM_LOG_DEBUG,
"config file %s, line %d: no include found for %s\n",
file, linenum, value);
break;
default:
for(gindex = 0; gindex < globbuf.gl_pathc; gindex++) {
pm_printf(ALPM_LOG_DEBUG, "config file %s, line %d: including %s\n",
file, linenum, globbuf.gl_pathv[gindex]);
ret = parse_ini(globbuf.gl_pathv[gindex], _parse_directive, data);
if(ret) {
goto cleanup;
}
}
break;
}
cleanup:
section->depth--;
globfree(&globbuf);
return ret;
}
int main (int argc, char * argv[]) {
gameType game;
game_ini(&game);
parse_ini(argc, argv, &game);
return 0;
}
int main(int argc, char **argv)
{
int sock;
int ret;
char buf[256];
struct state state;
char *program_name;
if ( (program_name=strrchr(argv[0], '/'))!=NULL) { /* Get root program name */
program_name++;
} else {
program_name = argv[0];
}
memset(&state, 0, sizeof(state));
fap_init();
if (parse_opts(argc, argv, &state)) {
printf("Invalid option(s)\n");
exit(1);
}
if (parse_ini(state.conf.config ? state.conf.config : "aprs.ini", &state)) {
printf("Invalid config\n");
exit(1);
}
sock = aprsis_connect(state.conf.aprsis_server_host_addr,
state.conf.aprsis_server_port,
state.basecall,
state.conf.aprsis_filter);
if (sock < 0) {
printf("Sock %i: %m\n", sock);
printf("Failed to connect with host: %s, port: %d, call: %s, filter: %s\n",
state.conf.aprsis_server_host_addr,
state.conf.aprsis_server_port,
state.basecall,
state.conf.aprsis_filter);
return 1;
}
while ((ret = read(sock, buf, sizeof(buf)))) {
int i;
for (i = 0; i < ret; i++) {
if (buf[i] != '*')
write(1, &buf[i], 1);
}
write(1, "\r", 1);
//buf[ret] = 0;
//printf("Got: %s\n", buf);
}
return 0;
}
int main(int argc, const char *argv[])
{
parse_ini("cfg.ini", ini_parser, NULL);
int fd = create_server(1001, 1);
if( fd == -1 ) return 0;
while(1)
{
udp_receive(fd, packet_recvier);
}
return 0;
}
/** Parse a configuration file.
* @param file path to the config file
* @return 0 on success, non-zero on error
*/
int parseconfig(const char *file)
{
int ret;
struct section_t section;
memset(§ion, 0, sizeof(struct section_t));
pm_printf(ALPM_LOG_DEBUG, "config: attempting to read file %s\n", file);
if((ret = parse_ini(file, _parse_directive, §ion))) {
return ret;
}
pm_printf(ALPM_LOG_DEBUG, "config: finished parsing %s\n", file);
if((ret = setup_libalpm())) {
return ret;
}
alpm_list_free_inner(config->repos, (alpm_list_fn_free) config_repo_free);
alpm_list_free(config->repos);
config->repos = NULL;
return ret;
}
/** Loads configuration string in app_config_buffer. */
static int8_t
_app_config_load_microSD()
{
int fd;
// And open it
fd = cfs_open("inga.cfg", CFS_READ);
// In case something goes wrong, we cannot save this file
if (fd == -1) {
log_e("Failed opening config file\n");
return -1;
}
// do nothing if modification timestamp of file is older/equal than stored
#if CONF_FILE_TIMESTAMP_CHECK
log_i("Checking config file timestamp...\n");
if ((cfs_fat_get_last_date(fd) <= system_config._mod_date)
&& (cfs_fat_get_last_time(fd) <= system_config._mod_time)) {
log_i("Config file is older than stored config, will not be loaded\n");
cfs_close(fd);
return -1;
}
#endif
// update modification timestamps
system_config._mod_date = cfs_fat_get_last_date(fd);
system_config._mod_time = cfs_fat_get_last_time(fd);
int size = cfs_read(fd, app_config_buffer, MAX_FILE_SIZE);
app_config_buffer[size] = '\0'; // string null terminator
log_v("actually read: %d\n", size);
log_i("Loaded data from microSD card\n");
cfs_close(fd);
parse_ini(app_config_buffer, &inga_conf_file);
app_config_update();
return 0;
}
int main(int argc, char *argv[])
{
INI *ini;
ARGS *args;
if (argc < 2)
usage(argv[0]);
args = parseargs(argc, argv);
if(args == -1) {
fprintf(stderr, "Wrong Option\n");
usage(argv[0]);
}
ini = parse_ini(argv[argc - 1], args);
if(!ini)
fprintf(stderr, "check the file\n");
print_ini(ini);
return 0;
}
static hFILE * s3_rewrite(const char *s3url, const char *mode, va_list *argsp)
{
const char *bucket, *path;
char *header_list[4], **header = header_list;
kstring_t url = { 0, 0, NULL };
kstring_t profile = { 0, 0, NULL };
kstring_t host_base = { 0, 0, NULL };
kstring_t token_hdr = { 0, 0, NULL };
s3_auth_data *ad = calloc(1, sizeof(*ad));
if (!ad)
return NULL;
ad->mode = strchr(mode, 'r') ? 'r' : 'w';
// Our S3 URL format is s3[+SCHEME]://[ID[:SECRET[:TOKEN]]@]BUCKET/PATH
if (s3url[2] == '+') {
bucket = strchr(s3url, ':') + 1;
kputsn(&s3url[3], bucket - &s3url[3], &url);
}
else {
kputs("https:", &url);
bucket = &s3url[3];
}
while (*bucket == '/') kputc(*bucket++, &url);
path = bucket + strcspn(bucket, "/?#@");
if (*path == '@') {
const char *colon = strpbrk(bucket, ":@");
if (*colon != ':') {
urldecode_kput(bucket, colon - bucket, &profile);
}
else {
const char *colon2 = strpbrk(&colon[1], ":@");
urldecode_kput(bucket, colon - bucket, &ad->id);
urldecode_kput(&colon[1], colon2 - &colon[1], &ad->secret);
if (*colon2 == ':')
urldecode_kput(&colon2[1], path - &colon2[1], &ad->token);
}
bucket = &path[1];
path = bucket + strcspn(bucket, "/?#");
}
else {
// If the URL has no ID[:SECRET]@, consider environment variables.
const char *v;
if ((v = getenv("AWS_ACCESS_KEY_ID")) != NULL) kputs(v, &ad->id);
if ((v = getenv("AWS_SECRET_ACCESS_KEY")) != NULL) kputs(v, &ad->secret);
if ((v = getenv("AWS_SESSION_TOKEN")) != NULL) kputs(v, &ad->token);
if ((v = getenv("AWS_DEFAULT_PROFILE")) != NULL) kputs(v, &profile);
else if ((v = getenv("AWS_PROFILE")) != NULL) kputs(v, &profile);
else kputs("default", &profile);
}
if (ad->id.l == 0) {
const char *v = getenv("AWS_SHARED_CREDENTIALS_FILE");
parse_ini(v? v : "~/.aws/credentials", profile.s,
"aws_access_key_id", &ad->id,
"aws_secret_access_key", &ad->secret,
"aws_session_token", &ad->token, NULL);
}
if (ad->id.l == 0)
parse_ini("~/.s3cfg", profile.s, "access_key", &ad->id,
"secret_key", &ad->secret, "access_token", &ad->token,
"host_base", &host_base, NULL);
if (ad->id.l == 0)
parse_simple("~/.awssecret", &ad->id, &ad->secret);
if (host_base.l == 0)
kputs("s3.amazonaws.com", &host_base);
// Use virtual hosted-style access if possible, otherwise path-style.
if (is_dns_compliant(bucket, path)) {
kputsn(bucket, path - bucket, &url);
kputc('.', &url);
kputs(host_base.s, &url);
}
else {
kputs(host_base.s, &url);
kputc('/', &url);
kputsn(bucket, path - bucket, &url);
}
kputs(path, &url);
if (ad->token.l > 0) {
kputs("X-Amz-Security-Token: ", &token_hdr);
kputs(ad->token.s, &token_hdr);
*header++ = token_hdr.s;
}
ad->bucket = strdup(bucket);
if (!ad->bucket)
goto fail;
*header = NULL;
hFILE *fp = hopen(url.s, mode, "va_list", argsp, "httphdr:v", header_list,
"httphdr_callback", auth_header_callback,
"httphdr_callback_data", ad, NULL);
if (!fp) goto fail;
free(url.s);
free(profile.s);
free(host_base.s);
free(token_hdr.s);
return fp;
fail:
free(url.s);
free(profile.s);
free(host_base.s);
free(token_hdr.s);
free_auth_data(ad);
return NULL;
}
// 配置初始化
void ini_init(void)
{
NIni* ini;
FILE* fd;
if (l_nbk_ini)
return;
ini = (NIni*)NBK_malloc0(sizeof(NIni));
l_nbk_ini = ini;
ini->work_path = (char*)NBK_malloc(NBK_MAX_PATH);
ini->data_path = (char*)NBK_malloc(NBK_MAX_PATH);
ini->font_path = (char*)NBK_malloc(NBK_MAX_PATH);
// 获取工作目录
#ifdef PLATFORM_WIN32
_getcwd(ini->work_path, NBK_MAX_PATH);
#endif
#ifdef PLATFORM_LINUX
getcwd(ini->work_path, NBK_MAX_PATH);
#endif
nbk_strcpy(ini->data_path, ini->work_path);
nbk_strcpy(ini->font_path, ini->work_path);
// 默认值
ini->kv[NEINI_DATA_PATH] = NBK_DATA_PATH;
//ini->kv[NEINI_TTF_FONT] = NBK_TTF_FONT;
ini->kv[NEINI_HOMEPAGE] = NBK_HOMEPAGE;
ini->kv[NEINI_TESTPAGE] = NBK_TESTPAGE;
ini->kv[NEINI_PAGE_ERROR] = NBK_PAGE_ERROR;
ini->kv[NEINI_PAGE_404] = NBK_PAGE_404;
ini->kv[NEINI_WIDTH] = NBK_WIDTH;
ini->kv[NEINI_HEIGHT] = NBK_HEIGHT;
ini->kv[NEINI_CBS] = NBK_CBS;
ini->kv[NEINI_MPIC] = NBK_MPIC;
ini->kv[NEINI_TF] = NBK_TF;
ini->kv[NEINI_PLATFORM] = NBK_PLATFORM;
ini->kv[NEINI_FROM] = NBK_FROM;
ini->kv[NEINI_IMAGE_QUALITY] = NBK_IMG_QUALITY;
// 读入ini
fd = fopen(NBK_INI, "rb");
if (fd) {
int size;
fseek(fd, 0, SEEK_END);
size = ftell(fd);
fseek(fd, 0, SEEK_SET);
if (size) {
ini->conf = (char*)NBK_malloc(size + 1);
size = fread(ini->conf, 1, size, fd);
ini->conf[size] = 0;
parse_ini(ini, size);
// 产生缓存绝对路径
path_convert(ini->data_path, ini->kv[NEINI_DATA_PATH]);
// 产生字体绝对路径
if (ini->kv[NEINI_TTF_FONT]) { // 使用用户设置
path_convert(ini->font_path, ini->kv[NEINI_TTF_FONT]);
}
else { // 使用默认设置
#ifdef PLATFORM_WIN32
char* windir = getenv("windir");
sprintf(ini->font_path, "%s%s", windir, NBK_TTF_FONT);
#else
path_convert(ini->font_path, NBK_TTF_FONT);
#endif
}
}
fclose(fd);
}
else {
fprintf(stderr, "NBK: nbk.ini not found!\n");
}
}
__declspec(dllexport) void __cdecl VDDDispatch(void)
{
char str[512];
DWORD count;
DWORD msgs;
int retval;
int node_num;
BYTE* p;
vdd_status_t* status;
static DWORD writes;
static DWORD bytes_written;
static DWORD reads;
static DWORD bytes_read;
static DWORD inbuf_poll;
static DWORD online_poll;
static DWORD status_poll;
static DWORD vdd_yields;
static DWORD vdd_calls;
VDD_IO_HANDLERS IOHandlers = { NULL };
static VDD_IO_PORTRANGE PortRange;
retval=0;
node_num=getBH();
lprintf(LOG_DEBUG,"VDD_OP: (handle=%d) %d (arg=%X)", getAX(),getBL(),getCX());
vdd_calls++;
switch(getBL()) {
case VDD_OPEN:
sscanf("$Revision: 1.40 $", "%*s %s", revision);
lprintf(LOG_INFO,"Synchronet Virtual Device Driver, rev %s %s %s"
,revision, __DATE__, __TIME__);
#if 0
sprintf(str,"sbbsexec%d.log",node_num);
fp=fopen(str,"wb");
#endif
sprintf(str,"\\\\.\\mailslot\\sbbsexec\\wr%d",node_num);
rdslot=CreateMailslot(str
,0 //LINEAR_RX_BUFLEN /* Max message size (0=any) */
,MAILSLOT_WAIT_FOREVER /* Read timeout */
,NULL);
if(rdslot==INVALID_HANDLE_VALUE) {
lprintf(LOG_ERR,"!VDD_OPEN: Error %d opening %s"
,GetLastError(),str);
retval=1;
break;
}
sprintf(str,"\\\\.\\mailslot\\sbbsexec\\rd%d",node_num);
wrslot=CreateFile(str
,GENERIC_WRITE
,FILE_SHARE_READ
,NULL
,OPEN_EXISTING
,FILE_ATTRIBUTE_NORMAL
,(HANDLE) NULL);
if(wrslot==INVALID_HANDLE_VALUE) {
lprintf(LOG_ERR,"!VDD_OPEN: Error %d opening %s"
,GetLastError(),str);
retval=2;
break;
}
if(RingBufInit(&rdbuf, RINGBUF_SIZE_IN)!=0) {
retval=3;
break;
}
sprintf(str,"sbbsexec_hungup%d",node_num);
hungup_event=OpenEvent(
EVENT_ALL_ACCESS, /* access flag */
FALSE, /* inherit flag */
str); /* pointer to event-object name */
if(hungup_event==NULL) {
lprintf(LOG_ERR,"!VDD_OPEN: Error %d opening %s"
,GetLastError(),str);
retval=4;
break;
}
sprintf(str,"sbbsexec_hangup%d",node_num);
hangup_event=OpenEvent(
EVENT_ALL_ACCESS, /* access flag */
FALSE, /* inherit flag */
str); /* pointer to event-object name */
if(hangup_event==NULL) {
lprintf(LOG_WARNING,"!VDD_OPEN: Error %d opening %s"
,GetLastError(),str);
}
status_poll=0;
inbuf_poll=0;
online_poll=0;
yields=0;
lprintf(LOG_INFO,"Yield interval: %f milliseconds", yield_interval);
if(virtualize_uart) {
lprintf(LOG_INFO,"Virtualizing UART (0x%x, IRQ %u)"
,uart_io_base, uart_irq);
IOHandlers.inb_handler = uart_rdport;
IOHandlers.outb_handler = uart_wrport;
PortRange.First=uart_io_base;
PortRange.Last=uart_io_base + UART_IO_RANGE;
VDDInstallIOHook((HANDLE)getAX(), 1, &PortRange, &IOHandlers);
interrupt_event=CreateEvent(NULL,FALSE,FALSE,NULL);
InitializeCriticalSection(&interrupt_mutex);
_beginthread(interrupt_thread, 0, NULL);
}
lprintf(LOG_DEBUG,"VDD_OPEN: Opened successfully (wrslot=%p)", wrslot);
_beginthread(input_thread, 0, NULL);
retval=0;
break;
case VDD_CLOSE:
lprintf(LOG_INFO,"VDD_CLOSE: rdbuf=%u "
"status_poll=%u inbuf_poll=%u online_poll=%u yields=%u vdd_yields=%u vdd_calls=%u"
,RingBufFull(&rdbuf),status_poll,inbuf_poll,online_poll
,yields,vdd_yields,vdd_calls);
lprintf(LOG_INFO," read=%u bytes (in %u calls)",bytes_read,reads);
lprintf(LOG_INFO," wrote=%u bytes (in %u calls)",bytes_written,writes);
if(virtualize_uart) {
lprintf(LOG_INFO,"Uninstalling Virtualizaed UART IO Hook");
VDDDeInstallIOHook((HANDLE)getAX(), 1, &PortRange);
}
CloseHandle(rdslot);
CloseHandle(wrslot);
if(hungup_event!=NULL)
CloseHandle(hungup_event);
if(hangup_event!=NULL)
CloseHandle(hangup_event);
#if 0 /* This isn't strictly necessary...
and possibly the cause of a NULL dereference in the input_thread */
RingBufDispose(&rdbuf);
#endif
status_poll=0;
retval=0;
break;
case VDD_READ:
count = getCX();
if(count != 1)
lprintf(LOG_DEBUG,"VDD_READ of %d",count);
p = (BYTE*) GetVDMPointer((ULONG)((getES() << 16)|getDI())
,count,FALSE);
retval=vdd_read(p, count);
reads++;
bytes_read+=retval;
reset_yield();
break;
case VDD_PEEK:
count = getCX();
if(count != 1)
lprintf(LOG_DEBUG,"VDD_PEEK of %d",count);
p = (BYTE*) GetVDMPointer((ULONG)((getES() << 16)|getDI())
,count,FALSE);
retval=RingBufPeek(&rdbuf,p,count);
reset_yield();
break;
case VDD_WRITE:
count = getCX();
if(count != 1)
lprintf(LOG_DEBUG,"VDD_WRITE of %d",count);
p = (BYTE*) GetVDMPointer((ULONG)((getES() << 16)|getDI())
,count,FALSE);
if(!WriteFile(wrslot,p,count,&retval,NULL)) {
lprintf(LOG_ERR,"!VDD_WRITE: WriteFile Error %d (size=%d)"
,GetLastError(),retval);
retval=0;
} else {
writes++;
bytes_written+=retval;
reset_yield();
}
break;
case VDD_STATUS:
status_poll++;
count = getCX();
if(count != sizeof(vdd_status_t)) {
lprintf(LOG_DEBUG,"!VDD_STATUS: wrong size (%d!=%d)",count,sizeof(vdd_status_t));
retval=sizeof(vdd_status_t);
break;
}
status = (vdd_status_t*) GetVDMPointer((ULONG)((getES() << 16)|getDI())
,count,FALSE);
status->inbuf_size=RINGBUF_SIZE_IN;
status->inbuf_full=RingBufFull(&rdbuf);
msgs=0;
/* OUTBUF FULL/SIZE */
if(!GetMailslotInfo(
wrslot, /* mailslot handle */
&status->outbuf_size, /* address of maximum message size */
&status->outbuf_full, /* address of size of next message */
&msgs, /* address of number of messages */
NULL /* address of read time-out */
)) {
lprintf(LOG_ERR,"!VDD_STATUS: GetMailSlotInfo(%p) failed, error %u (msgs=%u, inbuf_full=%u, inbuf_size=%u)"
,wrslot
,GetLastError(), msgs, status->inbuf_full, status->inbuf_size);
status->outbuf_full=0;
status->outbuf_size=DEFAULT_MAX_MSG_SIZE;
} else
lprintf(LOG_DEBUG,"VDD_STATUS: MailSlot maxmsgsize=%u, nextmsgsize=%u, msgs=%u"
,status->outbuf_size
,status->outbuf_full
,msgs);
if(status->outbuf_full==MAILSLOT_NO_MESSAGE)
status->outbuf_full=0;
status->outbuf_full*=msgs;
/* ONLINE */
if(WaitForSingleObject(hungup_event,0)==WAIT_OBJECT_0)
status->online=0;
else
status->online=1;
retval=0; /* success */
break;
case VDD_INBUF_PURGE:
RingBufReInit(&rdbuf);
retval=0;
break;
case VDD_OUTBUF_PURGE:
lprintf(LOG_WARNING,"!VDD_OUTBUF_PURGE: NOT IMPLEMENTED");
retval=0;
break;
case VDD_INBUF_FULL:
retval=RingBufFull(&rdbuf);
inbuf_poll++;
break;
case VDD_INBUF_SIZE:
retval=RINGBUF_SIZE_IN;
break;
case VDD_OUTBUF_FULL:
if(!GetMailslotInfo(
wrslot, /* mailslot handle */
NULL, /* address of maximum message size */
&retval, /* address of size of next message */
&msgs, /* address of number of messages */
NULL /* address of read time-out */
))
retval=0;
if(retval==MAILSLOT_NO_MESSAGE)
retval=0;
retval*=msgs;
break;
case VDD_OUTBUF_SIZE:
if(!GetMailslotInfo(
wrslot, /* mailslot handle */
&retval, /* address of maximum message size */
NULL, /* address of size of next message */
NULL, /* address of number of messages */
NULL /* address of read time-out */
))
retval=DEFAULT_MAX_MSG_SIZE;
break;
case VDD_ONLINE:
if(WaitForSingleObject(hungup_event,0)==WAIT_OBJECT_0)
retval=0;
else
retval=1;
online_poll++;
break;
case VDD_YIELD: /* forced yield */
vdd_yields++;
yield();
break;
case VDD_MAYBE_YIELD: /* yield if YieldInterval is enabled and expired */
maybe_yield();
break;
case VDD_LOAD_INI_FILE: /* Load and parse settings file */
{
FILE* fp;
char cwd[MAX_PATH+1];
/* Load exec/sbbsexec.ini first (setting default values) */
count = getCX();
p = (BYTE*)GetVDMPointer((ULONG)((getES() << 16)|getDI())
,count,FALSE);
iniFileName(ini_fname, sizeof(ini_fname), p, INI_FILENAME);
if((fp=fopen(ini_fname,"r"))!=NULL) {
ini=iniReadFile(fp);
fclose(fp);
parse_ini(ROOT_SECTION);
}
/* Load cwd/sbbsexec.ini second (over-riding default values) */
GetCurrentDirectory(sizeof(cwd),cwd);
iniFileName(ini_fname, sizeof(ini_fname), cwd, INI_FILENAME);
if((fp=fopen(ini_fname,"r"))!=NULL) {
ini=iniReadFile(fp);
fclose(fp);
parse_ini(ROOT_SECTION);
}
}
break;
case VDD_LOAD_INI_SECTION: /* Parse (program-specific) sub-section of settings file */
count = getCX();
p = (BYTE*)GetVDMPointer((ULONG)((getES() << 16)|getDI())
,count,FALSE);
parse_ini(p);
break;
case VDD_DEBUG_OUTPUT: /* Send string to debug output */
count = getCX();
p = (BYTE*)GetVDMPointer((ULONG)((getES() << 16)|getDI())
,count,FALSE);
lputs(LOG_INFO, p);
break;
case VDD_HANGUP:
hangup();
break;
default:
lprintf(LOG_ERR,"!UNKNOWN VDD_OP: %d",getBL());
break;
}
setAX((WORD)retval);
}
static int
add_s3_settings(hFILE_libcurl *fp, const char *s3url, kstring_t *message)
{
int ret, save;
const char *bucket, *path;
char date_hdr[40];
CURLcode err;
kstring_t url = { 0, 0, NULL };
kstring_t profile = { 0, 0, NULL };
kstring_t id = { 0, 0, NULL };
kstring_t secret = { 0, 0, NULL };
kstring_t token = { 0, 0, NULL };
kstring_t token_hdr = { 0, 0, NULL };
kstring_t auth_hdr = { 0, 0, NULL };
time_t now = time(NULL);
#ifdef HAVE_GMTIME_R
struct tm tm_buffer;
struct tm *tm = gmtime_r(&now, &tm_buffer);
#else
struct tm *tm = gmtime(&now);
#endif
strftime(date_hdr, sizeof date_hdr, "Date: %a, %d %b %Y %H:%M:%S GMT", tm);
if (add_header(fp, date_hdr) < 0) goto error;
kputs(&date_hdr[6], message);
kputc('\n', message);
// Our S3 URL format is s3[+SCHEME]://[ID[:SECRET[:TOKEN]]@]BUCKET/PATH
if (s3url[2] == '+') {
bucket = strchr(s3url, ':') + 1;
kputsn(&s3url[3], bucket - &s3url[3], &url);
}
else {
kputs("https:", &url);
bucket = &s3url[3];
}
while (*bucket == '/') kputc(*bucket++, &url);
path = bucket + strcspn(bucket, "/?#@");
if (*path == '@') {
const char *colon = strpbrk(bucket, ":@");
if (*colon != ':') {
urldecode_kput(bucket, colon - bucket, fp, &profile);
}
else {
const char *colon2 = strpbrk(&colon[1], ":@");
urldecode_kput(bucket, colon - bucket, fp, &id);
urldecode_kput(&colon[1], colon2 - &colon[1], fp, &secret);
if (*colon2 == ':')
urldecode_kput(&colon2[1], path - &colon2[1], fp, &token);
}
bucket = &path[1];
path = bucket + strcspn(bucket, "/?#");
}
else {
// If the URL has no ID[:SECRET]@, consider environment variables.
const char *v;
if ((v = getenv("AWS_ACCESS_KEY_ID")) != NULL) kputs(v, &id);
if ((v = getenv("AWS_SECRET_ACCESS_KEY")) != NULL) kputs(v, &secret);
if ((v = getenv("AWS_SESSION_TOKEN")) != NULL) kputs(v, &token);
if ((v = getenv("AWS_DEFAULT_PROFILE")) != NULL) kputs(v, &profile);
else if ((v = getenv("AWS_PROFILE")) != NULL) kputs(v, &profile);
else kputs("default", &profile);
}
// Use virtual hosted-style access if possible, otherwise path-style.
if (is_dns_compliant(bucket, path)) {
kputsn(bucket, path - bucket, &url);
kputs(".s3.amazonaws.com", &url);
}
else {
kputs("s3.amazonaws.com/", &url);
kputsn(bucket, path - bucket, &url);
}
kputs(path, &url);
if (id.l == 0) {
const char *v = getenv("AWS_SHARED_CREDENTIALS_FILE");
parse_ini(v? v : "~/.aws/credentials", profile.s,
"aws_access_key_id", &id, "aws_secret_access_key", &secret,
"aws_session_token", &token, NULL);
}
if (id.l == 0)
parse_ini("~/.s3cfg", profile.s, "access_key", &id,
"secret_key", &secret, "access_token", &token, NULL);
if (id.l == 0)
parse_simple("~/.awssecret", &id, &secret);
if (token.l > 0) {
kputs("x-amz-security-token:", message);
kputs(token.s, message);
kputc('\n', message);
kputs("X-Amz-Security-Token: ", &token_hdr);
kputs(token.s, &token_hdr);
if (add_header(fp, token_hdr.s) < 0) goto error;
}
kputc('/', message);
kputs(bucket, message); // CanonicalizedResource is '/' + bucket + path
err = curl_easy_setopt(fp->easy, CURLOPT_URL, url.s);
if (err != CURLE_OK) { errno = easy_errno(fp->easy, err); goto error; }
// If we have no id/secret, we can't sign the request but will
// still be able to access public data sets.
if (id.l > 0 && secret.l > 0) {
unsigned char digest[DIGEST_BUFSIZ];
size_t digest_len = s3_sign(digest, &secret, message);
kputs("Authorization: AWS ", &auth_hdr);
kputs(id.s, &auth_hdr);
kputc(':', &auth_hdr);
base64_kput(digest, digest_len, &auth_hdr);
if (add_header(fp, auth_hdr.s) < 0) goto error;
}
ret = 0;
goto free_and_return;
error:
ret = -1;
free_and_return:
save = errno;
free(url.s);
free(profile.s);
free(id.s);
free(secret.s);
free(token.s);
free(token_hdr.s);
free(auth_hdr.s);
free(message->s);
errno = save;
return ret;
}
static int cfg_parse(const char *path)
{
return parse_ini(path, cfg_parser);
}
