/*
* Remove a parameter from an existing emsMIMEtype structure. This structure
* should be created using make_mime_type().
*
* NOTE: All input strings are COPIED before permanent use.
*
* Args:
* mimePtr [IN] Pointer to the emsMIMEtype structure to altered
* name [IN] Name of the parameter to be removed
*
* Returns: Boolean (TRUE = success, FALSE = failure)
*/
int remove_mime_parameter(emsMIMEtypeP mimePtr, const char *name)
{
if (!mimePtr)
return (FALSE);
emsMIMEParamP paramPtr = mimePtr->params, prevParamPtr = NULL;
/* Find the parameter */
while (paramPtr)
{
if (strcmp(paramPtr->name, name) == 0)
break;
prevParamPtr = paramPtr;
paramPtr = paramPtr->next;
}
if (!paramPtr)
return (FALSE); /* Not found */
if (prevParamPtr == NULL) /* Removing first in list */
mimePtr->params = paramPtr->next;
else
prevParamPtr->next = paramPtr->next;
paramPtr->next = NULL;
free_param_type(paramPtr);
return (TRUE);
}
/*
* Add a parameter to an existing emsMIMEtype structure. This structure
* should be created using make_mime_type().
*
* NOTE: All input strings are COPIED before permanent use.
*
* Args:
* mimePtr [IN] Pointer to the emsMIMEtype structure to be added too
* name [IN] Name of the parameter
* value [IN] Value of the parameter
*
* Returns: Boolean (TRUE = success, FALSE = failure)
*/
int add_mime_parameter(emsMIMEtypeP mimePtr, const char *name, const char *value)
{
if (!mimePtr)
return (FALSE);
emsMIMEParamP paramPtr = (emsMIMEParamP) malloc (sizeof(emsMIMEparam));
if (paramPtr)
{
paramPtr->name = strdup(name);
paramPtr->value = strdup(value);
paramPtr->next = NULL;
if ((paramPtr->name) && (paramPtr->value))
{
emsMIMEParamP *paramEnd = &(mimePtr->params);
while (*paramEnd)
paramEnd = &((*paramEnd)->next);
*paramEnd = paramPtr;
return (TRUE);
}
}
// If we get here then something went wrong
// Do complete cleanup
free_param_type(paramPtr);
return (FALSE);
}
/*
* Free an emsMIMEtype structure, including all strings and parameters.
*
* Args:
* mimePtr [IN] Pointer to the emsMIMEtype structure to be freed
*
* No return value.
*/
void free_mime_type(emsMIMEtypeP mimePtr)
{
if (mimePtr)
{
safefree(mimePtr->type);
safefree(mimePtr->subType);
safefree(mimePtr->version);
free_param_type(mimePtr->params);
safefree(mimePtr);
}
}
void _pf_free_param_file (Param_File_Type *p)
{
Param_Type *pf, *pf_next;
if (p == NULL) return;
pf = p->pf;
while (pf != NULL)
{
pf_next = pf->next;
free_param_type (pf);
pf = pf_next;
}
if (p->input_filename != NULL) SLFREE (p->input_filename);
if (p->output_filename != NULL) SLFREE (p->output_filename);
SLFREE (p);
}
static Param_Type *create_param_type (char *line)
{
Param_Type *p;
char *name, *type, *mode, *min, *max, *value, *prompt;
p = (Param_Type *) _pf_malloc (sizeof (Param_Type));
if (p == NULL) return NULL;
if (NULL == (p->name = _pf_create_string (line)))
{
goto free_and_return_error;
}
/* p->name is special. See comment in pf.h */
if (-1 == chop_line (line, &name, &type, &mode, &value, &min, &max, &prompt))
{
goto free_and_return_error;
}
p->name[strlen (name)] = 0;
if (type == NULL)
{
p->type = PF_COMMENT_TYPE;
return p;
}
if (-1 == parse_type (type, &p->type))
{
goto free_and_return_error;
}
if (-1 == _pf_parse_mode (mode, &p->mode))
{
goto free_and_return_error;
}
if (min != NULL)
{
if (NULL == (p->min = _pf_unescape_string (min)))
goto free_and_return_error;
}
if (max != NULL)
{
if (NULL == (p->max = _pf_unescape_string (max)))
goto free_and_return_error;
}
if (value != NULL)
{
if (NULL == (p->value = _pf_unescape_string (value)))
goto free_and_return_error;
/* This is a weakness in the definition of parameter files. There
* seems to be NO WAY to have a parameter whose value begins with
* a ')' character. Actually, I think there is but the existing
* practice seems to defeat my solution.
*/
if (*p->value == ')')
p->flags |= PF_INDIRECT_VALUE;
}
if (prompt != NULL)
{
if (NULL == (p->prompt = _pf_unescape_string (prompt)))
goto free_and_return_error;
}
return p;
free_and_return_error:
if ((p != NULL) && (p->name != NULL))
{
pf_error ("Error processing parameter/line %s", p->name);
}
free_param_type (p);
return NULL;
}
