/*********************************************************************************************************
** 函数名称: API_BlkRawCreate
** 功能描述: 通过 /dev/blk/xxx 块设备生成一个 BLOCK 控制块 (只能内核程序调用).
** 输 入 : pcBlkName 块设备名称
** bRdOnly 只读
** bLogic 是否为逻辑分区
** pblkraw 创建的 blk raw 控制块
** 输 出 : ERROR_NONE or PX_ERROR
** 全局变量:
** 调用模块:
** API 函数
*********************************************************************************************************/
LW_API
INT API_BlkRawCreate (CPCHAR pcBlkName, BOOL bRdOnly, BOOL bLogic, PLW_BLK_RAW pblkraw)
{
INT iFlag;
INT iRet;
if (!pcBlkName || !pblkraw) {
_ErrorHandle(EINVAL);
return (PX_ERROR);
}
iFlag = (bRdOnly) ? O_RDONLY : O_RDWR;
lib_bzero(pblkraw, sizeof(LW_BLK_RAW));
pblkraw->BLKRAW_blkd.BLKD_pcName = lib_strdup(pcBlkName);
if (pblkraw == LW_NULL) {
_ErrorHandle(ENOMEM);
return (PX_ERROR);
}
__KERNEL_SPACE_ENTER();
iRet = __blkRawCreate(pblkraw, iFlag, bLogic);
__KERNEL_SPACE_EXIT();
if (iRet < ERROR_NONE) {
__SHEAP_FREE(pblkraw);
}
return (iRet);
}
static int tftp_fileop_open(void **ref,void *fsctx,char *filename,int mode)
{
tftp_info_t *info;
char *host;
char *file;
int res;
if ((mode != FILE_MODE_READ) && (mode != FILE_MODE_WRITE)) {
/* must be either read or write, not both */
return CFE_ERR_UNSUPPORTED;
}
/* Allocate the tftp info structure */
info = KMALLOC(sizeof(tftp_info_t),0);
if (!info) {
return CFE_ERR_NOMEM;
}
info->tftp_filename = lib_strdup(filename);
if (!info->tftp_filename) {
KFREE(info);
return CFE_ERR_NOMEM;
}
lib_chop_filename(info->tftp_filename,&host,&file);
/* Open the file */
if (!*host && !*file) {
/* TFTP server if hostname and filename are not specified */
#ifdef RESCUE_MODE
xprintf("TFTP Server.\n");
#endif
res = _tftpd_open(info,host,file,mode);
} else {
/* TFTP client otherwise */
#ifdef RESCUE_MODE
xprintf("TFTP Client.\n");
#endif
res = _tftp_open(info,host,file,mode);
}
if (res == 0) {
info->tftp_blkoffset = 0;
info->tftp_fileoffset = 0;
*ref = info;
}
else {
KFREE(info->tftp_filename);
KFREE(info);
*ref = NULL;
}
return res;
}
void cmd_build_cmdline(queue_t *head, ui_cmdline_t *cmd)
{
ui_token_t *t;
ui_token_t *next;
memset(cmd, 0, sizeof(ui_cmdline_t));
t = (ui_token_t *) q_deqnext(head);
while (t != NULL) {
if (is_white_space(t)) {
/* do nothing */
}
else if (t->token != '-') {
if(cmd->argc < MAX_TOKENS){
cmd->argv[cmd->argc] = cmd_eat_quoted_arg(head,t);
cmd->argc++;
}
/* Token is a switch */
}
else {
if (cmd->swc < MAX_SWITCHES) {
cmd->swv[cmd->swc].swname = lib_strdup(&(t->token));
if (t->qb.q_next != head) { /* more tokens */
next = (ui_token_t *) t->qb.q_next;
if (next->token == '=') { /* switch has value */
KFREE(t); /* Free switch name */
t = (ui_token_t *) q_deqnext(head); /* eat equal sign */
KFREE(t); /* and free it */
t = (ui_token_t *) q_deqnext(head); /* now have value */
if (t != NULL) {
cmd->swv[cmd->swc].swvalue = cmd_eat_quoted_arg(head,t);
}
}
else { /* no value */
cmd->swv[cmd->swc].swvalue = NULL;
}
}
/*
* swidx is the index of the argument that this
* switch precedes. So, if you have "foo -d bar",
* swidx for "-d" would be 1.
*/
cmd->swv[cmd->swc].swidx = cmd->argc;
cmd->swc++;
}
}
KFREE(t);
t = (ui_token_t *) q_deqnext(head);
}
}
/*********************************************************************************************************
** 函数名称: lib_xstrdup
** 功能描述:
** 输 入 :
** 输 出 :
** 全局变量:
** 调用模块:
*********************************************************************************************************/
PCHAR lib_xstrdup (CPCHAR pcStr)
{
PCHAR pcStrRet = lib_strdup(pcStr);
if (pcStrRet == LW_NULL) {
#if (LW_CFG_DEVICE_EN > 0) && (LW_CFG_FIO_LIB_EN > 0)
perror("lib_xstrdup() not enough memory");
#endif /* (LW_CFG_DEVICE_EN > 0)... */
exit(0);
}
return (pcStrRet);
}
int lib_setoptions(const cons_t *list,char *str,unsigned int *flags)
{
char *dupstr;
char *x;
char *ptr;
const cons_t *val;
int newbits;
int errors = 0;
if (!list || !str || !flags) return 0;
dupstr = lib_strdup(str);
if (!dupstr) return 0;
ptr = dupstr;
while (*ptr) {
if ((x = lib_strchr(ptr,','))) {
*x = '\0';
}
val = lib_findinlist(list,ptr);
newbits = 0;
if (!val) {
if (lib_memcmp(ptr,"no_",3) == 0) {
val = lib_findinlist(list,ptr+3);
}
else if (lib_memcmp(ptr,"no",2) == 0) {
val = lib_findinlist(list,ptr+2);
}
if (val) newbits = ~((unsigned int) (val->num));
else errors++;
}
else {
newbits = (val->num);
}
/* if new bits are negative, it's an AND mask
otherwise it's an OR mask */
if (newbits < 0) *flags &= (unsigned int) newbits;
else *flags |= (unsigned int) newbits;
if (x) ptr = x+1;
else break;
}
KFREE(dupstr);
return errors;
}
static int http_fileop_open(void **ref,void *fsctx_arg,char *filename,int mode)
{
http_fsctx_t *fsctx;
http_file_t *file;
char temp[200];
char *hostname, *filen;
int hlen;
int termidx;
int res;
int err = 0;
char *hptr;
char *tok;
uint8_t hostaddr[IP_ADDR_LEN];
uint8_t termstr[4];
uint8_t b;
if (mode != FILE_MODE_READ) return CFE_ERR_UNSUPPORTED;
fsctx = (http_fsctx_t *) fsctx_arg;
file = KMALLOC(sizeof(http_file_t),0);
if (!file) {
return CFE_ERR_NOMEM;
}
file->http_filename = lib_strdup(filename);
if (!file->http_filename) {
KFREE(file);
return CFE_ERR_NOMEM;
}
lib_chop_filename(file->http_filename,&hostname,&filen);
/*
* Look up remote host
*/
res = dns_lookup(hostname,hostaddr);
if (res < 0) {
KFREE(file);
return res;
}
file->http_socket = tcp_socket();
if (file->http_socket < 0) {
KFREE(file->http_filename);
KFREE(file);
return -1;
}
/*
* Connect to remote host.
*/
tcp_setflags(file->http_socket,0); /* set socket to blocking */
res = tcp_connect(file->http_socket,hostaddr,80);
if (res < 0) {
tcp_close(file->http_socket);
KFREE(file->http_filename);
KFREE(file);
return res;
}
/*
* Send GET command. Supply the hostname (for HTTP 1.1 requirements)
* and set the connection to close as soon as all the data is received.
*/
hlen = sprintf(temp,"GET /%s HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n\r\n",filen,hostname);
res = tcp_send(file->http_socket,temp,hlen);
if (res < 0) {
tcp_close(file->http_socket);
KFREE(file->http_filename);
KFREE(file);
return res;
}
/*
* Read bytes until we either reach EOF or we see "\r\n\r\n"
* This is the server's status string.
*/
termstr[0] = '\r'; termstr[1] = '\n';
termstr[2] = '\r'; termstr[3] = '\n';
termidx = 0;
file->http_offset = 0;
file->http_blen = 0;
file->http_bptr = file->http_buffer;
res = 0;
for (;;) {
res = tcp_recv(file->http_socket,&b,1);
if (res < 0) break;
if (b == termstr[termidx]) {
termidx++;
if (termidx == 4) break;
}
else {
termidx = 0;
}
/*
* Save the bytes from the header up to our buffer
* size. It's okay if we don't save it all,
* since all we want is the result code which comes
* first.
*/
if (file->http_blen < (HTTP_BUFSIZE-1)) {
*(file->http_bptr) = b;
file->http_bptr++;
file->http_blen++;
}
}
/*
* Premature EOFs are not good, bail now.
*/
if (res < 0) {
err = CFE_ERR_EOF;
goto protocolerr;
}
/*
* Skip past the HTTP response header and grab the result code.
* Sanity check it a little.
*/
*(file->http_bptr) = 0;
hptr = file->http_buffer;
tok = lib_gettoken(&hptr);
if (!tok || (memcmp(tok,"HTTP",4) != 0)) {
err = CFE_ERR_PROTOCOLERR;
goto protocolerr;
}
tok = lib_gettoken(&hptr);
if (!tok) {
err = CFE_ERR_PROTOCOLERR;
goto protocolerr;
}
switch (lib_atoi(tok)) {
case 200:
err = 0;
break;
case 404:
err = CFE_ERR_FILENOTFOUND;
break;
}
/*
* If we get to here, the file is okay and we're about to receive data.
*/
if (err == 0) {
*ref = file;
return 0;
}
protocolerr:
tcp_close(file->http_socket);
KFREE(file->http_filename);
KFREE(file);
*ref = NULL;
return err;
}
static char *cmd_eat_quoted_arg(queue_t *head,ui_token_t *t)
{
int dquote = 0;
int squote = 0;
queue_t qlist;
queue_t *q;
char *dest;
int maxlen = 0;
/*
* If it's not a quoted string, just return this token.
*/
if (!myisquote(t->token)) {
dest = lib_strdup(&(t->token));
/* Note: caller deletes original token */
return dest;
}
/*
* Otherwise, eat tokens in the quotes.
*/
q_init(&qlist);
if (t->token == '"') dquote = 1;
else squote = 1; /* must be one or the other */
t = (ui_token_t *) q_deqnext(head);
while (t != NULL) {
/* A single quote can only be terminated by another single quote */
if (squote && (t->token == '\'')) {
KFREE(t);
break;
}
/* A double quote is only honored if not in a single quote */
if (dquote && !squote && (t->token == '\"')) {
KFREE(t);
break;
}
/* Otherwise, keep this token. */
q_enqueue(&qlist,(queue_t *) t);
t = (ui_token_t *) q_deqnext(head);
}
/*
* Go back through what we collected and figure out the string length.
*/
for (q = qlist.q_next; q != &qlist; q = q->q_next) {
maxlen += strlen(&(((ui_token_t *) q)->token));
}
dest = KMALLOC(maxlen+1,0);
if (!dest) return NULL;
*dest = '\0';
while ((t = (ui_token_t *) q_deqnext(&qlist))) {
strcat(dest,&(t->token));
KFREE(t);
}
return dest;
}
