char *
replace_string(const char *string, const char *substr, const char *replacement)
{
char *str_cpy = strdup(string);
char *pch;
char *ret;
Eina_Strbuf *buffer = eina_strbuf_new();
pch = strtok(str_cpy, substr);
eina_strbuf_append(buffer, pch);
while ((pch = strtok(NULL, substr)))
eina_strbuf_append_printf(buffer, "%s%s", replacement, pch);
ret = strdup(eina_strbuf_string_get(buffer));
free(str_cpy);
eina_strbuf_free(buffer);
return ret;
}
void
_update_time_part(Evas_Object *obj, const char *part, double t)
{
Eina_Strbuf *str;
double s;
int h, m;
s = t;
h = (int)(s / 3600.0);
s -= h * 3600;
m = (int)(s / 60.0);
s -= m * 60;
str = eina_strbuf_new();
eina_strbuf_append_printf(str, "%02d:%02d:%02d", h, m, (int)s);
elm_object_part_text_set(obj, part, eina_strbuf_string_get(str));
eina_strbuf_free(str);
}
static inline void
_introspect_append_signal(Eina_Strbuf *buf, const Eldbus_Signal *sig)
{
eina_strbuf_append_printf(buf, "<signal name=\"%s\"", sig->name);
if (!sig->flags && !(sig->args && sig->args->signature))
{
eina_strbuf_append(buf, " />");
return;
}
eina_strbuf_append(buf, ">");
if (sig->flags & ELDBUS_SIGNAL_FLAG_DEPRECATED)
eina_strbuf_append(buf, DBUS_ANNOTATION_DEPRECATED);
_introspect_arguments_append(buf, sig->args, NULL);
eina_strbuf_append(buf, "</signal>");
}
Eina_Bool
_alert_command_del(void *data,
int type EINA_UNUSED,
void *event)
{
Module_Alert_Command *mac = data;
Ecore_Exe_Event_Del *del = event;
const char *val;
if (mac != ecore_exe_data_get(del->exe)) return EINA_TRUE;
DBG("mac[%p] del[%p]", mac, del);
val = gotham_citizen_var_get(mac->gotham->me, mac->command->name);
DBG("val[%s] value[%s]", val, eina_strbuf_string_get(mac->buf));
if (!val) goto set_var;
if (strcmp(val, eina_strbuf_string_get(mac->buf)))
{
Eina_Strbuf *buf = eina_strbuf_new();
EINA_SAFETY_ON_NULL_GOTO(buf, clean_mac);
eina_strbuf_append_printf(buf, ".notification send %s Variable '%s' changed from '%s' to '%s'",
strlen(mac->command->notification) ? mac->command->notification : "dev",
mac->command->name, val,
eina_strbuf_string_get(mac->buf));
gotham_citizen_send(mac->gotham->alfred, eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
}
set_var:
gotham_citizen_var_set(mac->gotham->me, mac->command->name, eina_strbuf_string_get(mac->buf));
clean_mac:
_alert_command_clean(mac);
return EINA_TRUE;
}
char *
_dbus_package_to_path(const char *pkg)
{
Eina_Strbuf *buffer;
char *ret;
buffer = eina_strbuf_new();
eina_strbuf_append_char(buffer, '/');
for (; *pkg != '\0'; pkg++)
{
if (*pkg == '.')
eina_strbuf_append_char(buffer, '/');
else if(isalnum(*pkg))
eina_strbuf_append_char(buffer, *pkg);
else
eina_strbuf_append_printf(buffer, "_%02x", *pkg);
}
ret = eina_strbuf_string_steal(buffer);
eina_strbuf_free(buffer);
return ret;
}
static void
_append_char_escaped(Eina_Strbuf *buf, char c)
{
switch (c)
{
case '\'': eina_strbuf_append(buf, "\\\'"); break;
case '\"': eina_strbuf_append(buf, "\\\""); break;
case '\?': eina_strbuf_append(buf, "\\\?"); break;
case '\\': eina_strbuf_append(buf, "\\\\"); break;
case '\a': eina_strbuf_append(buf, "\\a"); break;
case '\b': eina_strbuf_append(buf, "\\b"); break;
case '\f': eina_strbuf_append(buf, "\\f"); break;
case '\n': eina_strbuf_append(buf, "\\n"); break;
case '\r': eina_strbuf_append(buf, "\\r"); break;
case '\t': eina_strbuf_append(buf, "\\t"); break;
case '\v': eina_strbuf_append(buf, "\\v"); break;
default:
if ((c < 32) || (c > 126))
eina_strbuf_append_printf(buf, "\\x%X", (unsigned char)c);
else
eina_strbuf_append_char(buf, c);
break;
}
}
static void
_gen_func(const Eolian_Unit *src, const Eolian_Class *cl,
const Eolian_Function *fid, Eolian_Function_Type ftype,
Eina_Strbuf *buf, const Eolian_Implement *impl, Eina_Strbuf *lbuf)
{
Eina_Bool is_empty = eolian_implement_is_empty(impl, ftype);
Eina_Bool is_auto = eolian_implement_is_auto(impl, ftype);
if ((ftype != EOLIAN_PROP_GET) && (ftype != EOLIAN_PROP_SET))
ftype = eolian_function_type_get(fid);
Eina_Bool is_prop = (ftype == EOLIAN_PROP_GET || ftype == EOLIAN_PROP_SET);
Eina_Bool var_as_ret = EINA_FALSE;
const Eolian_Expression *def_ret = NULL;
const Eolian_Type *rtp = eolian_function_return_type_get(fid, ftype);
if (rtp)
{
is_auto = EINA_FALSE; /* can't do auto if func returns */
def_ret = eolian_function_return_default_value_get(fid, ftype);
}
const char *func_suffix = "";
if (ftype == EOLIAN_PROP_GET)
{
func_suffix = "_get";
if (!rtp)
{
void *d1, *d2;
Eina_Iterator *itr = eolian_property_values_get(fid, ftype);
if (eina_iterator_next(itr, &d1) && !eina_iterator_next(itr, &d2))
{
Eolian_Function_Parameter *pr = d1;
rtp = eolian_parameter_type_get(pr);
var_as_ret = EINA_TRUE;
def_ret = eolian_parameter_default_value_get(pr);
}
eina_iterator_free(itr);
}
}
else if (ftype == EOLIAN_PROP_SET)
func_suffix = "_set";
Eina_Strbuf *params = eina_strbuf_new(); /* par1, par2, par3, ... */
Eina_Strbuf *params_full = eina_strbuf_new(); /* T par1, U par2, ... for decl */
Eina_Strbuf *params_full_imp = eina_strbuf_new(); /* as above, for impl */
Eina_Strbuf *params_init = eina_strbuf_new(); /* default value inits */
Eina_Stringshare *promise_param_name = NULL;
Eina_Stringshare *promise_param_type = NULL;
/* property keys */
{
Eina_Iterator *itr = eolian_property_keys_get(fid, ftype);
Eolian_Function_Parameter *pr;
EINA_ITERATOR_FOREACH(itr, pr)
{
const char *prn = eolian_parameter_name_get(pr);
const Eolian_Type *pt = eolian_parameter_type_get(pr);
Eina_Stringshare *ptn = eolian_type_c_type_get(pt);
if (eina_strbuf_length_get(params))
eina_strbuf_append(params, ", ");
eina_strbuf_append(params, prn);
eina_strbuf_append_printf(params_full, ", %s", ptn);
eina_strbuf_append_printf(params_full_imp, ", %s", ptn);
if (ptn[strlen(ptn) - 1] != '*')
{
eina_strbuf_append_char(params_full, ' ');
eina_strbuf_append_char(params_full_imp, ' ');
}
eina_strbuf_append(params_full, prn);
eina_strbuf_append(params_full_imp, prn);
if (is_empty || is_auto)
eina_strbuf_append(params_full_imp, " EINA_UNUSED");
eina_stringshare_del(ptn);
}
eina_iterator_free(itr);
}
/* property values or method params if applicable */
if (!var_as_ret)
{
Eina_Iterator *itr;
if (is_prop)
itr = eolian_property_values_get(fid, ftype);
else
itr = eolian_function_parameters_get(fid);
Eolian_Function_Parameter *pr;
EINA_ITERATOR_FOREACH(itr, pr)
{
Eolian_Parameter_Dir pd = eolian_parameter_direction_get(pr);
const Eolian_Expression *dfv = eolian_parameter_default_value_get(pr);
const char *prn = eolian_parameter_name_get(pr);
const Eolian_Type *pt = eolian_parameter_type_get(pr);
Eina_Stringshare *ptn = eolian_type_c_type_get(pt);
Eina_Bool had_star = ptn[strlen(ptn) - 1] == '*';
const char *add_star = _get_add_star(ftype, pd);
if (eina_strbuf_length_get(params))
eina_strbuf_append(params, ", ");
eina_strbuf_append(params_full_imp, ", ");
eina_strbuf_append(params_full_imp, ptn);
if (!had_star)
eina_strbuf_append_char(params_full_imp, ' ');
eina_strbuf_append(params_full_imp, add_star);
eina_strbuf_append(params_full_imp, prn);
if (!dfv && is_empty)
eina_strbuf_append(params_full_imp, " EINA_UNUSED");
eina_strbuf_append(params, prn);
eina_strbuf_append(params_full, ", ");
eina_strbuf_append(params_full, ptn);
if (!had_star)
eina_strbuf_append_char(params_full, ' ');
eina_strbuf_append(params_full, add_star);
eina_strbuf_append(params_full, prn);
if (is_auto)
{
if (ftype == EOLIAN_PROP_SET)
eina_strbuf_append_printf(params_init, " %s = pd->%s;\n", prn, prn);
else
{
eina_strbuf_append_printf(params_init, " if (%s) *%s = pd->%s;\n",
prn, prn, prn);
}
}
else if ((ftype != EOLIAN_PROP_SET) && dfv)
{
Eolian_Value val = eolian_expression_eval(src, dfv, EOLIAN_MASK_ALL);
if (val.type)
{
Eina_Stringshare *vals = eolian_expression_value_to_literal(&val);
eina_strbuf_append_printf(params_init, " if (%s) *%s = %s;",
prn, prn, vals);
eina_stringshare_del(vals);
if (eolian_expression_type_get(dfv) == EOLIAN_EXPR_NAME)
{
Eina_Stringshare *vs = eolian_expression_serialize(dfv);
eina_strbuf_append_printf(params_init, " /* %s */", vs);
eina_stringshare_del(vs);
}
eina_strbuf_append_char(params_init, '\n');
}
}
eina_stringshare_del(ptn);
}
E_API E_About *
e_about_new(void)
{
E_Obj_Dialog *od;
char buf[16384];
FILE *f;
Eina_Strbuf *tbuf;
od = e_obj_dialog_new(_("About Enlightenment"), "E", "_about");
if (!od) return NULL;
e_obj_dialog_obj_theme_set(od, "base/theme/about", "e/widgets/about/main");
e_obj_dialog_obj_part_text_set(od, "e.text.label", _("Close"));
e_obj_dialog_obj_part_text_set(od, "e.text.title", _("Enlightenment"));
e_obj_dialog_obj_part_text_set(od, "e.text.version", VERSION);
snprintf
(buf, sizeof(buf), "%s%s",
_(
"<title>Copyright © 2000-2015, by the Enlightenment "
"Development Team</><br>"
"<br>"
"We hope you enjoy using this software as much as we enjoyed "
"writing it.<br>"
"<br>"
"To contact us please visit:<br>"
"<hilight>http://www.enlightenment.org</><br>"
"<br>"
),
"All rights reserved.<br>"
"<br>"
"Redistribution and use in source and binary forms, with or without "
"modification, are permitted provided that the following conditions "
"are met:<br>"
"<br>"
"1. Redistributions of source code must retain the above copyright "
"notice, this list of conditions and the following disclaimer.<br>"
"2. Redistributions in binary form must reproduce the above copyright "
"notice, this list of conditions and the following disclaimer in the "
"documentation and/or other materials provided with the "
"distribution.<br>"
"<br>"
"<hilight>THIS SOFTWARE IS PROVIDED “AS IS” AND ANY EXPRESS OR "
"IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED "
"WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE "
"ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR "
"CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, "
"SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT "
"LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF "
"USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED "
"AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT "
"LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN "
"ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE "
"POSSIBILITY OF SUCH DAMAGE.</><br>"
);
e_obj_dialog_obj_part_text_set(od, "e.textblock.about", buf);
e_prefix_data_concat_static(buf, "AUTHORS");
f = fopen(buf, "r");
if (f)
{
tbuf = eina_strbuf_new();
eina_strbuf_append(tbuf, _("<title>The Team</><br><br>"));
while (fgets(buf, sizeof(buf), f))
{
int len;
len = strlen(buf);
if (len > 0)
{
if (buf[len - 1] == '\n')
{
buf[len - 1] = 0;
len--;
}
if (len > 0)
{
char *p;
do
{
p = strchr(buf, '<');
if (p) *p = 0;
}
while (p);
do
{
p = strchr(buf, '>');
if (p) *p = 0;
}
while (p);
eina_strbuf_append_printf(tbuf, "%s<br>", buf);
}
}
}
fclose(f);
if (tbuf)
{
e_obj_dialog_obj_part_text_set(od, "e.textblock.authors",
eina_strbuf_string_get(tbuf));
eina_strbuf_free(tbuf);
}
}
return (E_About *)od;
}
static void
_gen_func(const Eolian_Unit *src, const Eolian_Function *fid,
Eolian_Function_Type ftype, Eina_Strbuf *buf, char *cname,
char *cnameu, Eina_Bool legacy)
{
Eina_Stringshare *fcn = eolian_function_full_c_name_get(fid, ftype, legacy);
if (!fcn)
return;
Eina_Bool var_as_ret = EINA_FALSE;
const Eolian_Type *rtp = eolian_function_return_type_get(fid, ftype);
if (ftype == EOLIAN_PROP_GET && !rtp)
{
void *d1, *d2;
Eina_Iterator *itr = eolian_property_values_get(fid, ftype);
if (eina_iterator_next(itr, &d1) && !eina_iterator_next(itr, &d2))
{
rtp = eolian_parameter_type_get((Eolian_Function_Parameter *)d1);
var_as_ret = EINA_TRUE;
}
eina_iterator_free(itr);
}
Eolian_Object_Scope fsc = eolian_function_scope_get(fid, ftype);
/* this one will never be satisfied in legacy */
if (eolian_function_is_beta(fid))
eina_strbuf_append_printf(buf, "#ifdef %s_BETA\n", cnameu);
/* XXX: is this right? we expose potentially internal stuff into legacy */
if (!legacy && (fsc == EOLIAN_SCOPE_PROTECTED))
eina_strbuf_append_printf(buf, "#ifdef %s_PROTECTED\n", cnameu);
const Eolian_Implement *fimp = eolian_function_implement_get(fid);
Eina_Bool hasdoc = !!eolian_implement_documentation_get(fimp, ftype);
if (!hasdoc && ((ftype == EOLIAN_PROP_GET) || (ftype == EOLIAN_PROP_SET)))
hasdoc = !!eolian_implement_documentation_get(fimp, EOLIAN_PROPERTY);
if (hasdoc)
{
Eina_Strbuf *dbuf = eo_gen_docs_func_gen(src, fid, ftype, 0, legacy);
eina_strbuf_append(buf, eina_strbuf_string_get(dbuf));
eina_strbuf_append_char(buf, '\n');
eina_strbuf_free(dbuf);
}
eina_strbuf_append(buf, legacy ? "EAPI " : "EOAPI ");
if (rtp)
{
Eina_Stringshare *rtps = eolian_type_c_type_get(rtp);
eina_strbuf_append(buf, rtps);
if (rtps[strlen(rtps) - 1] != '*')
eina_strbuf_append_char(buf, ' ');
eina_stringshare_del(rtps);
}
else
eina_strbuf_append(buf, "void ");
eina_strbuf_append(buf, fcn);
eina_stringshare_del(fcn);
Eina_Bool first = EINA_TRUE;
Eina_Strbuf *flagbuf = NULL;
int nidx = !legacy || !eolian_function_is_class(fid);
eina_strbuf_append_char(buf, '(');
if (nidx)
{
if ((ftype == EOLIAN_PROP_GET) || eolian_function_object_is_const(fid)
|| eolian_function_is_class(fid))
{
eina_strbuf_append(buf, "const ");
}
if (legacy)
eina_strbuf_append_printf(buf, "%s *obj", cname);
else
eina_strbuf_append(buf, "Eo *obj");
first = EINA_FALSE;
}
{
Eolian_Function_Parameter *pr = NULL;
Eina_Iterator *itr = eolian_property_keys_get(fid, ftype);
EINA_ITERATOR_FOREACH(itr, pr)
{
const Eolian_Type *prt = eolian_parameter_type_get(pr);
const char *prn = eolian_parameter_name_get(pr);
Eina_Stringshare *prtn = eolian_type_c_type_get(prt);
++nidx;
if (!first)
eina_strbuf_append(buf, ", ");
eina_strbuf_append_printf(buf, "%s %s", prtn, prn);
eina_stringshare_del(prtn);
first = EINA_FALSE;
if (!eolian_parameter_is_nonull(pr))
continue;
if (!flagbuf)
{
flagbuf = eina_strbuf_new();
eina_strbuf_append_printf(flagbuf, " EINA_ARG_NONNULL(%d", nidx);
}
else
eina_strbuf_append_printf(flagbuf, ", %d", nidx);
}
eina_iterator_free(itr);
}
if (!var_as_ret)
{
Eina_Iterator *itr = NULL;
if (ftype == EOLIAN_PROP_GET || ftype == EOLIAN_PROP_SET)
itr = eolian_property_values_get(fid, ftype);
else
itr = eolian_function_parameters_get(fid);
Eolian_Function_Parameter *pr = NULL;
EINA_ITERATOR_FOREACH(itr, pr)
{
const Eolian_Type *prt = eolian_parameter_type_get(pr);
const char *prn = eolian_parameter_name_get(pr);
Eina_Stringshare *prtn = eolian_type_c_type_get(prt);
++nidx;
if (!first)
eina_strbuf_append(buf, ", ");
eina_strbuf_append(buf, prtn);
if (prtn[strlen(prtn) - 1] != '*')
eina_strbuf_append_char(buf, ' ');
eina_strbuf_append(buf,
_get_add_star(ftype, eolian_parameter_direction_get(pr)));
eina_strbuf_append(buf, prn);
eina_stringshare_del(prtn);
first = EINA_FALSE;
if (!eolian_parameter_is_nonull(pr))
continue;
if (!flagbuf)
{
flagbuf = eina_strbuf_new();
eina_strbuf_append_printf(flagbuf, " EINA_ARG_NONNULL(%d", nidx);
}
else
eina_strbuf_append_printf(flagbuf, ", %d", nidx);
}
eina_iterator_free(itr);
}
char *
esql_query_escape(Eina_Bool backslashes,
size_t *len,
const char *fmt,
va_list args)
{
Eina_Strbuf *buf;
const char *p, *pp;
char *ret = NULL;
size_t fmtlen;
buf = eina_strbuf_new();
*len = 0;
fmtlen = strlen(fmt);
pp = strchr(fmt, '%');
if (!pp) pp = fmt + fmtlen;
for (p = fmt; p && *p; pp = strchr(p, '%'))
{
Eina_Bool l = EINA_FALSE;
Eina_Bool ll = EINA_FALSE;
long long int i;
double d;
char *s;
if (!pp) pp = fmt + fmtlen;
EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append_length(buf, p, ((pp - p > 1) ? pp - p : 1)), err);
if (*pp != '%') break; /* no more fmt strings */
top:
switch (pp[1])
{
case 0:
ERR("Invalid format string!");
goto err;
case 'l':
if (!l)
l = EINA_TRUE;
else if (!ll)
ll = EINA_TRUE;
else
{
ERR("Invalid format string!");
goto err;
}
pp++;
goto top;
case 'f':
if (l && ll)
{
ERR("Invalid format string!");
goto err;
}
d = va_arg(args, double);
EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append_printf(buf, "%lf", d), err);
break;
case 'i':
case 'd':
if (l && ll)
i = va_arg(args, long long int);
else if (l)
i = va_arg(args, long int);
else
i = va_arg(args, int);
EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append_printf(buf, "%lli", i), err);
break;
case 's':
if (l)
{
ERR("Invalid format string!");
goto err;
}
s = va_arg(args, char *);
if (!s) break;
s = esql_string_escape(backslashes, s);
EINA_SAFETY_ON_NULL_GOTO(s, err);
EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append(buf, s), err);
free(s);
break;
case 'c':
if (l)
{
ERR("Invalid format string!");
goto err;
}
{
char c[3];
c[0] = va_arg(args, int);
c[1] = c[2] = 0;
s = esql_string_escape(backslashes, c);
EINA_SAFETY_ON_NULL_GOTO(s, err);
EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append(buf, s), err);
free(s);
}
break;
case '%':
EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append_char(buf, '%'), err);
break;
default:
ERR("Unsupported format string: '%s'!", pp);
goto err;
}
char *
_nedje_text_escape(const char *text)
{
Eina_Strbuf *txt;
char *ret;
const char *text_end;
size_t text_len;
Eina_Array *arr;
const char *cur_tag = NULL;
if (!text) return NULL;
txt = eina_strbuf_new();
text_len = strlen(text);
arr = eina_array_new(3);
text_end = text + text_len;
while (text < text_end)
{
int advance;
if ((text[0] == '<') && text[1])
{
const char *tag, *popped;
Eina_Bool closing = EINA_FALSE;
if (text[1] == '/') //closing tag
{
closing = EINA_TRUE;
tag = _get_tag(text + 2);
}
else
tag = _get_tag(text + 1);
if (closing)
{
if (cur_tag && (tag != cur_tag))
{
/* tag mismatch: autoclose all failure tags
* not technically required by the spec,
* but it makes me feel better about myself
*/
do
{
popped = eina_array_pop(arr);
if (eina_array_count(arr))
cur_tag = eina_array_data_get(arr, eina_array_count(arr) - 1);
else
cur_tag = NULL;
eina_strbuf_append_printf(txt, "</%c>", popped[1]);
} while (cur_tag && (popped != tag));
advance = 4;
}
else if (cur_tag)
{
/* tag match: just pop */
popped = eina_array_pop(arr);
if (eina_array_count(arr))
cur_tag = eina_array_data_get(arr, eina_array_count(arr) - 1);
else
cur_tag = NULL;
eina_strbuf_append_printf(txt, "</%c>", popped[1]);
advance = 4;
}
else
{
/* no current tag: escape */
advance = _text_escape(txt, text);
}
}
else
{
if (tag)
{
cur_tag = tag;
eina_array_push(arr, tag);
eina_strbuf_append_printf(txt, "<%c>", tag[1]);
advance = 3;
}
else
advance = _text_escape(txt, text);
}
}
else if (text[0] == '&')
{
const char *s;
s = strchr(text, ';');
if (s)
s = evas_textblock_escape_string_range_get(text, s + 1);
if (s)
{
eina_strbuf_append_char(txt, text[0]);
advance = 1;
}
else
advance = _text_escape(txt, text);
}
else
advance = _text_escape(txt, text);
text += advance;
}
eina_array_free(arr);
ret = eina_strbuf_string_steal(txt);
eina_strbuf_free(txt);
return ret;
}
/* externally accessible functions */
int
main(int argc,
char **argv)
{
int i, gn;
int test = 0;
Eina_Bool mnt = EINA_FALSE;
char *action, *cmd;
uid_t uid;
gid_t gid, gl[65536], egid;
for (i = 1; i < argc; i++)
{
if ((!strcmp(argv[i], "-h")) ||
(!strcmp(argv[i], "-help")) ||
(!strcmp(argv[i], "--help")))
{
printf(
"This is an internal tool for Enlightenment.\n"
"do not use it.\n"
);
exit(0);
}
}
if (argc >= 3)
{
if ((argc == 3) && (!strcmp(argv[1], "-t")))
{
test = 1;
action = argv[2];
}
else
{
const char *s;
s = strrchr(argv[1], '/');
if ((!s) || (!(++s))) exit(1); /* eeze always uses complete path */
if (strcmp(s, "mount") && strcmp(s, "umount") && strcmp(s, "eject")) exit(1);
mnt = EINA_TRUE;
action = argv[1];
}
}
else if (argc == 2)
{
action = argv[1];
}
else
{
exit(1);
}
uid = getuid();
gid = getgid();
egid = getegid();
gn = getgroups(65536, gl);
if (gn < 0)
{
printf("ERROR: MEMBER OF MORE THAN 65536 GROUPS\n");
exit(3);
}
if (setuid(0) != 0)
{
printf("ERROR: UNABLE TO ASSUME ROOT PRIVILEGES\n");
exit(5);
}
if (setgid(0) != 0)
{
printf("ERROR: UNABLE TO ASSUME ROOT GROUP PRIVILEGES\n");
exit(7);
}
eina_init();
if (!auth_action_ok(action, uid, gid, gl, gn, egid))
{
printf("ERROR: ACTION NOT ALLOWED: %s\n", action);
exit(10);
}
/* we can add more levels of auth here */
/* when mounting, this will match the exact path to the exe,
* as required in sysactions.conf
* this is intentionally pedantic for security
*/
cmd = eina_hash_find(actions, action);
if (!cmd)
{
printf("ERROR: UNDEFINED ACTION: %s\n", action);
exit(20);
}
if ((!test) && (!mnt)) return system(cmd);
if (mnt)
{
Eina_Strbuf *buf;
int ret = 0;
const char *mp = NULL;
buf = eina_strbuf_new();
if (!buf) goto err;
for (i = 1; i < argc; i++)
{
if (!strncmp(argv[i], "/media/", 7))
{
mp = argv[i];
if (!strcmp(action, "mount"))
{
struct stat s;
if (stat("/media", &s))
{
mode_t um;
um = umask(0);
if (mkdir("/media", S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))
{
printf("ERROR: COULD NOT CREATE DIRECTORY /media\n");
exit(40);
}
umask(um);
}
else if (!S_ISDIR(s.st_mode))
{
printf("ERROR: NOT A DIRECTORY: /media\n");
exit(40);
}
if (stat(argv[i], &s))
{
mode_t um;
um = umask(0);
if (mkdir(argv[i], S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))
{
printf("ERROR: COULD NOT CREATE DIRECTORY %s\n", argv[i]);
exit(40);
}
umask(um);
}
else if (!S_ISDIR(s.st_mode))
{
printf("ERROR: NOT A DIRECTORY: %s\n", argv[i]);
exit(40);
}
}
}
eina_strbuf_append_printf(buf, "%s ", argv[i]);
}
ret = system(eina_strbuf_string_get(buf));
if ((!strcmp(action, "umount")) && (!ret))
{
if (rmdir(mp))
printf("ERROR: COULD NOT UNLINK MOUNT POINT %s\n", mp);
}
return ret;
}
eina_shutdown();
return 0;
err:
printf("ERROR: MEMORY CRISIS\n");
eina_shutdown();
return 30;
}
