int do_move(const char *filename,uint64_t lv,uint32_t ts,char *ptr) {
uint32_t inode,parent_src,parent_dst;
uint8_t name_src[256],name_dst[256];
EAT(ptr,filename,lv,'(');
GETU32(parent_src,ptr);
EAT(ptr,filename,lv,',');
GETNAME(name_src,ptr,filename,lv,',');
EAT(ptr,filename,lv,',');
GETU32(parent_dst,ptr);
EAT(ptr,filename,lv,',');
GETNAME(name_dst,ptr,filename,lv,')');
EAT(ptr,filename,lv,')');
EAT(ptr,filename,lv,':');
GETU32(inode,ptr);
return fs_log_move(ts,parent_src,strlen((char*)name_src),name_src,parent_dst,strlen((char*)name_dst),name_dst,inode);
}
/*
* init_mach_macros(void)
*
* Set the magic macros TARGET_MACH, HOST_MACH,
*
* Parameters:
*
* Global variables used:
* host_mach Property for magic macro HOST_MACH
* target_mach Property for magic macro TARGET_MACH
*
* Return value:
* The function does not return a value, but can
* call fatal() in case of error.
*/
static void
init_mach_macros(void)
{
FILE *pipe;
name_t *value;
const char *mach_command = NOCATGETS("/bin/mach");
string_t str;
wchar_t buf[STRING_BUFFER_LENGTH];
char fgetsbuf[100];
boolean_t set_host = B_FALSE, set_target = B_FALSE;
name_t *host_mach, *target_mach;
/*
* Skip out if we've already done this:
*/
if (init_mach_done == B_TRUE)
return;
init_mach_done = B_TRUE;
host_mach = _internal_get_magic_macro(MMI_HOST_MACH);
target_mach = _internal_get_magic_macro(MMI_TARGET_MACH);
/*
* If both have been set already, don't proceed any further:
*/
if (set_host == B_FALSE && set_target == B_FALSE)
return;
if (get_prop(host_mach->n_prop, PT_MACRO) == NULL)
set_host = B_TRUE;
if (get_prop(target_mach->n_prop, PT_MACRO) == NULL)
set_target = B_TRUE;
INIT_STRING_FROM_STACK(str, buf);
append_char(L'-', &str);
if ((pipe = popen(mach_command, "r")) == NULL) {
fatal_mksh(catgets(libmksdmsi18n_catd, 1, 183,
"Execute of %s failed"), mach_command);
}
while (fgets(fgetsbuf, sizeof (fgetsbuf), pipe) != NULL)
append_string(fgetsbuf, &str, FIND_LENGTH);
if (pclose(pipe) != 0) {
fatal_mksh(catgets(libmksdmsi18n_catd, 1, 184, "Execute of %s "
"failed"), mach_command);
}
value = GETNAME(str.str_buf_start, FIND_LENGTH);
if (set_host == B_TRUE) {
(void) setvar_daemon(host_mach, value, B_FALSE,
DN_NO_DAEMON, B_TRUE, 0);
}
if (set_target == B_TRUE) {
(void) setvar_daemon(target_mach, value, B_FALSE,
DN_NO_DAEMON, B_TRUE, 0);
}
}
uint8_t do_unlink(uint64_t lv,uint32_t ts,char *ptr) {
uint32_t inode,parent;
uint8_t name[256];
EAT(ptr,lv,'(');
GETU32(parent,ptr);
EAT(ptr,lv,',');
GETNAME(name,ptr,lv,')');
EAT(ptr,lv,')');
EAT(ptr,lv,':');
GETU32(inode,ptr);
return shadow_fs_unlink(ts,parent,strlen((char*)name),name,inode);
}
int do_unlink(const char *filename,uint64_t lv,uint32_t ts,char *ptr) {
uint32_t inode,parent;
uint8_t name[256];
EAT(ptr,filename,lv,'(');
GETU32(parent,ptr);
EAT(ptr,filename,lv,',');
GETNAME(name,ptr,filename,lv,')');
EAT(ptr,filename,lv,')');
EAT(ptr,filename,lv,':');
GETU32(inode,ptr);
return fs_log_unlink(ts,parent,strlen((char*)name),name,inode);
}
int do_snapshot(const char *filename,uint64_t lv,uint32_t ts,char *ptr) {
uint32_t inode,parent,canoverwrite;
uint8_t name[256];
EAT(ptr,filename,lv,'(');
GETU32(inode,ptr);
EAT(ptr,filename,lv,',');
GETU32(parent,ptr);
EAT(ptr,filename,lv,',');
GETNAME(name,ptr,filename,lv,',');
EAT(ptr,filename,lv,',');
GETU32(canoverwrite,ptr);
EAT(ptr,filename,lv,')');
return fs_log_snapshot(ts,inode,parent,strlen((char*)name),name,canoverwrite);
}
int do_setxattr(const char *filename,uint64_t lv,uint32_t ts,char *ptr) {
uint32_t inode,valueleng,mode;
uint8_t name[256];
static uint8_t *value = NULL;
static uint32_t valuesize = 0;
EAT(ptr,filename,lv,'(');
GETU32(inode,ptr);
EAT(ptr,filename,lv,',');
GETNAME(name,ptr,filename,lv,',');
EAT(ptr,filename,lv,',');
GETDATA(value,valueleng,valuesize,ptr,filename,lv,',');
EAT(ptr,filename,lv,',');
GETU32(mode,ptr);
EAT(ptr,filename,lv,')');
return fs_log_setxattr(ts,inode,strlen((char*)name),name,valueleng,value,mode);
}
/* the rest of the pattern segments */
#endif /* ANSI_PROTOTYPES */
{
char *saved_end = path_end; /* saved to be resored */
char *pat; /* current pattern segment */
struct stat st; /* to check if file exists */
#ifdef GLOBDEBUG
ffprintf(STDDBG,"do_glob: path = '%s', pat = '%s'\n", main_path, *gpat );
#endif
for ( ; (pat = *gpat) != 0 && no_glob(pat); gpat++ )
{
#ifdef GLOBDEBUG
ffprintf(STDDBG,"no_glob: path = '%s', pat = '%s'\n", main_path, pat );
#endif
*path_end = '/';
(void)strcpy(path_end+1, pat);
path_end += strlen(pat) + 1;
if (GLOBSTAT(main_path, &st) != 0 )
{
*saved_end = '\0';
return;
}
}
if (pat)
matchdir(path_end, gpat);
else
add_name();
*saved_end = '\0';
return;
}
static void
#ifndef ANSI_PROTOTYPES
matchdir(path_end, gpat)
char *path_end; /* ptr to end of main_path */
char **gpat; /* the rest of the pattern segments */
#else /* ANSI_PROTOTYPES */
matchdir(char *path_end, char **gpat)
/* ptr to end of main_path */
/* the rest of the pattern segments */
#endif /* ANSI_PROTOTYPES */
{
char *x; /* scratch */
VOIDDIR *dirp; /* for directory reading */
VOIDDIRENT *dp; /* directory entry */
struct stat st; /* to determine files type */
#ifdef GLOBDEBUG
ffprintf(STDDBG,"matchdir: path = '%s', pat = '%s'\n", main_path, *gpat );
#endif
if ((dirp = OPENDIR(main_path)) == NULL)
return;
*path_end = '/';
while ((dp = READDIR(dirp)) != NULL)
{
char *dirname;
x = dirname = GETNAME(dp); /* was dp->d_name */
if (*x == '.' && (*++x == '\0' || (*x == '.' && *++x == '\0')))
continue;
if (*dirname == '.' && **gpat != '.')
continue;
(void)strcpy(path_end + 1, dirname);
if (glob_match(*gpat, dirname))
{ /* this is a match */
if ( *(gpat+1) == 0 )
{ /* and it is the last */
add_name(); /* so eat it */
continue;
}
if (GLOBSTAT(main_path, &st) == 0 /* else not the last */
&& (st.st_mode & S_IFMT) == S_IFDIR)
do_glob(path_end + strlen(dirname) + 1, gpat + 1);
}
}
(void)CLOSEDIR(dirp);
*path_end = '\0';
}
uint8_t do_symlink(uint64_t lv,uint32_t ts,char *ptr) {
uint32_t parent,uid,gid,inode;
uint8_t name[256];
static uint8_t *path;
static uint32_t pathsize;
EAT(ptr,lv,'(');
GETU32(parent,ptr);
EAT(ptr,lv,',');
GETNAME(name,ptr,lv,',');
EAT(ptr,lv,',');
GETPATH(path,pathsize,ptr,lv,',');
EAT(ptr,lv,',');
GETU32(uid,ptr);
EAT(ptr,lv,',');
GETU32(gid,ptr);
EAT(ptr,lv,')');
EAT(ptr,lv,':');
GETU32(inode,ptr);
return shadow_fs_symlink(ts,parent,strlen((char*)name),name,path,uid,gid,inode);
}
int do_symlink(const char *filename,uint64_t lv,uint32_t ts,char *ptr) {
uint32_t parent,uid,gid,inode;
uint8_t name[256];
static uint8_t *path = NULL;
static uint32_t pathsize = 0;
EAT(ptr,filename,lv,'(');
GETU32(parent,ptr);
EAT(ptr,filename,lv,',');
GETNAME(name,ptr,filename,lv,',');
EAT(ptr,filename,lv,',');
GETPATH(path,pathsize,ptr,filename,lv,',');
EAT(ptr,filename,lv,',');
GETU32(uid,ptr);
EAT(ptr,filename,lv,',');
GETU32(gid,ptr);
EAT(ptr,filename,lv,')');
EAT(ptr,filename,lv,':');
GETU32(inode,ptr);
return fs_log_symlink(ts,parent,strlen((char*)name),name,path,uid,gid,inode);
}
static name_t *
_internal_get_magic_macro(magic_macro_id_t id)
{
if (id == MMI_UNKNOWN || id >= _MMI_MAX_ID) {
fprintf(stderr, "PROGRAMMING ERROR\n");
/*
* XXX
*/
abort();
}
if (magic_macros[id - 1] == NULL) {
/*
* Internalise the name:
*/
magic_macros[id - 1] = GETNAME(macro_names[id - 1],
FIND_LENGTH);
}
return (magic_macros[id - 1]);
}
/*
* getvar(name)
*
* Return expanded value of macro.
*
* Return value:
* The expanded value of the macro
*
* Parameters:
* name The name of the macro we want the value for
*
* Global variables used:
*/
name_t *
getvar(name_t *name)
{
string_t dest;
wchar_t buf[STRING_BUFFER_LENGTH];
name_t *result;
property_t *prop;
macro_t *macro;
INIT_STRING_FROM_STACK(dest, buf);
prop = maybe_append_prop(name, PT_MACRO);
if (prop->p_type != PT_MACRO)
abort();
macro = (macro_t *)prop->p_body;
expand_value(macro->m_value, &dest, B_FALSE);
result = GETNAME(dest.str_buf_start, FIND_LENGTH);
if (dest.str_free_after_use)
free(dest.str_buf_start);
return (result);
}
int do_create(const char *filename,uint64_t lv,uint32_t ts,char *ptr) {
uint32_t parent,mode,uid,gid,rdev,inode;
uint8_t type,name[256];
EAT(ptr,filename,lv,'(');
GETU32(parent,ptr);
EAT(ptr,filename,lv,',');
GETNAME(name,ptr,filename,lv,',');
EAT(ptr,filename,lv,',');
type = *ptr;
ptr++;
EAT(ptr,filename,lv,',');
GETU32(mode,ptr);
EAT(ptr,filename,lv,',');
GETU32(uid,ptr);
EAT(ptr,filename,lv,',');
GETU32(gid,ptr);
EAT(ptr,filename,lv,',');
GETU32(rdev,ptr);
EAT(ptr,filename,lv,')');
EAT(ptr,filename,lv,':');
GETU32(inode,ptr);
return fs_log_create(ts,parent,strlen((char*)name),name,type,mode,uid,gid,rdev,inode);
}
char* specialForm(Obj expr) { return GETNAME(CAR(expr)); }
bool isQuit(Obj expr) {
return GETTAG(expr) == NAME &&
cmpForm(GETNAME(expr), QUIT_COMMAND);
}
static void
_process_macro_name(string_t *str, string_t *dest, boolean_t cmd)
{
const wchar_t *colon_sh = L":sh";
const wchar_t *colon_shell = L":shell";
extraction_type_t extraction = EXT_NO;
name_t *name = NULL;
wchar_t *colon, *percent;
replacement_t rpl;
int i;
bzero(&rpl, sizeof (rpl));
/*
* First, check if we have a $(@D) type translation.
*/
if ((get_char_semantics_value(str->str_buf_start[0]) &
CHC_SPECIAL_MACRO) != 0) {
switch (str->str_buf_start[1]) {
case L'D':
extraction = EXT_DIR;
break;
case L'F':
extraction = EXT_FILE;
break;
default:
fatal_reader_mksh(catgets(libmksdmsi18n_catd, 1, 119,
"Illegal macro reference `%ls'"),
str->str_buf_start);
}
/*
* Internalise the macro name using the first character
* only:
*/
name = GETNAME(str->str_buf_start, 1);
/*
* XXX this seems slightly dodge:
*/
(void) wcscpy(str->str_buf_start, str->str_buf_start + 2);
}
/*
* Check for other kinds of translations.
*/
if ((colon = wcschr(str->str_buf_start, L':')) != NULL) {
/*
* We have a $(FOO:.c=.o) type translation.
* Get the name of the macro proper.
*/
if (name == NULL) {
name = GETNAME(str->str_buf_start,
colon - str->str_buf_start);
}
/*
* Pickup all the translations.
*/
if (wcscmp(colon, colon_sh) == 0 || wcscmp(colon,
colon_shell) == 0) {
rpl.rpl_type = RT_SHELL;
} else if (svr4 == B_TRUE || (percent = wcschr(colon + 1,
L'%')) == NULL) {
/*
* Straight substition -- .c=.o
*/
_parse_straight_subst(colon, &rpl);
} else {
/*
* Percent-style substition -- op%os=np%ns
*/
_parse_percent_subst(colon, &rpl);
}
}
if (name == NULL) {
/*
* No translations found.
* Use the whole string as the macro name.
*/
name = GETNAME(str->str_buf_start, str->str_p -
str->str_buf_start);
}
/*
* Take note of any special macro considerations:
*/
if (is_magic_macro_name(MMI_MAKE, name) == B_TRUE) {
make_word_mentioned = B_TRUE;
}
if (is_magic_macro_name(MMI_QUERY, name) == B_TRUE) {
query_mentioned = B_TRUE;
}
if (is_magic_macro_name(MMI_HOST_ARCH, name) == B_TRUE ||
is_magic_macro_name(MMI_TARGET_ARCH, name) == B_TRUE) {
init_arch_macros();
}
if (is_magic_macro_name(MMI_HOST_MACH, name) == B_TRUE ||
is_magic_macro_name(MMI_TARGET_MACH, name) == B_TRUE) {
init_mach_macros();
}
_get_macro_value(name, dest, &rpl, extraction, cmd);
free(rpl.rpl_left_head);
free(rpl.rpl_left_tail);
free(rpl.rpl_right_head);
free(rpl.rpl_right_tail);
for (i = 0; rpl.rpl_right_hand[i] != NULL; i++)
free(rpl.rpl_right_hand[i]);
}
int main (int argc, char *argv[])
{
FILE *fopen(), *fpin;
char *infile, *outbase, *outext, *filter;
char *ppa, *ppb;
char **pending_name;
int *pending_number;
int i, r;
int verbose_flag;
int begin_frame,max_frames;
int pp_flag;
int outtype;
infile = NULL;
outbase = NULL;
outext = NULL;
verbose_flag = 0;
filter = NULL;
begin_frame=1;
max_frames=-1;
outtype = PPM_RAW;
/* scan arguments */
pp_flag = 0;
pending_number = NULL;
pending_name = NULL;
ppa = ppb = NULL;
if (argc == 1)
{ print_usage(); exit(1); }
for (i=1; i < argc; i++)
{
ppa=argv[i];
if (pp_flag == 1)
{ SCANINT(ppa, pending_number); pp_flag = 0; }
else if (pp_flag == 2)
{ *pending_name = ppa; pp_flag = 0; }
else if (*ppa == '-')
{
ppb = (ppa++);
switch (*ppa)
{
case 'b': GETNUMBER(begin_frame); break;
case 'n': GETNUMBER(max_frames); break;
case 'a': outtype = PPM_ASCII; break;
case 'm': outtype = FBM_MAPPED; break;
case 'f': GETNAME(filter); break;
case 'v': verbose_flag = 1; break;
case 'h': print_usage(); print_help(); exit(1);
default:
fprintf(stderr,"Illegal option '%c' in argument %d\n",
*ppa,i);
print_hint();
exit(1);
}
}
else if (infile == NULL)
{
infile=argv[i];
}
else if (outbase == NULL)
{
outbase=argv[i];
}
else if (outext == NULL)
{
outext=argv[i];
}
else
{
fprintf(stderr,"Too many parameters specified\n");
print_hint();
exit(1);
}
}
if (pp_flag == 1)
{
fprintf(stderr,"Missing number behind option '%c'\n",*ppb);
print_hint();
exit(1);
}
if (outbase == NULL)
{
print_usage();
exit(1);
}
/* fprintf(stderr,"Open Input File\n"); */
if ((fpin = fopen(infile, "rb")) == NULL)
{
fprintf(stderr,"Error opening input file '%s'\n",infile);
exit(1);
}
r = unfli(fpin,outbase,outext,outtype,
begin_frame,max_frames,verbose_flag,filter);
if (r == 0)
fprintf(stderr,"Stop\n");
else if (r == 1)
fprintf(stderr,"Ready\n");
else if (r == -1)
fprintf(stderr,"Read error\n");
else if (r == -2)
fprintf(stderr,"Error allocating memory\n");
else
fprintf(stderr,"Unknown error\n");
fclose(fpin);
return(0);
}
char* specialForm(Obj expr) {
// return GETLIST(expr)->car.val.name;
return GETNAME(CAR(GETLIST(expr)));
}
