static mode_t get_mode (void)
{
mode_t m;
m = ch_cmode ^ (ch_cmode & 0777);
m |= get_perm (ch_flags, 6);
m |= get_perm (ch_flags + 3, 3);
m |= get_perm (ch_flags + 6, 0);
return m;
}
int my_ls(const char *name, int opt) {
struct stat stat_buf;
struct passwd *pw;
struct group *gr;
struct tm *tm;
char *perm;
int cnt = 0;
if (lstat(name, &stat_buf) < 0) {
warn("%s", name);
return -1;
}
if (start_flag & (opt & FLAG_R)) { /* option -R */
/* 아직 구현 못함 */
}
else if (!(start_flag++) && S_ISDIR(stat_buf.st_mode)) {
print_dir(name, opt);
} else if (opt & FLAG_L) { /* option -l */
perm = get_perm(name);
pw = getpwuid(stat_buf.st_uid);
gr = getgrgid(stat_buf.st_gid);
tm = localtime(&stat_buf.st_mtime);
printf("%s %2d %s %s %4d %02d %02d %02d:%02d %s\n",
perm, stat_buf.st_nlink, pw->pw_name, gr->gr_name, stat_buf.st_size,
tm->tm_mon+1, tm->tm_mday, tm->tm_hour, tm->tm_min, name);
free(perm);
} else { /* default option */
printf("%s\t", name);
}
return 0;
}
static void OURpermute(float *data,
float *result,
int n)
{
int i;
const int *pptr;
pptr = get_perm(n);
for (i=0; i<n; i++)
result[i] = data[pptr[i]];
}
void get_info(struct file_data_struct **file_data, struct stat *buf, char *file_name, int i){
struct passwd* user_data = getpwuid(buf -> st_uid);
struct group* group_data = getgrgid(buf -> st_gid);
char *user, *group, *perm, *str;
size_t file_data_size;
if (user_data == NULL)
my_error("error while getting information about user \n");
if (group_data == NULL)
my_error("error while getting information about group \n");
user = (char*)malloc(sizeof(char) * (strlen(user_data -> pw_name) + 11));
strcpy(user, "USER NAME:");
strcat(user, user_data -> pw_name);
strcat(user, "\n");
group = (char*)malloc(sizeof(char) * (strlen(group_data -> gr_name) + 12));
strcpy(group, "GROUP NAME:");
strcat (group, group_data -> gr_name);
//Make a string where we will store names of file user and group
str = (char*)malloc((strlen(group) + strlen(user) + strlen(file_name) + 11) * sizeof(char));
strcpy(str, "FILE NAME:");
strcat(str, file_name);
strcat(str, "\n");
strcat(str, user);
strcat(str, group);
file_data_size = (sizeof(struct file_data_struct) + strlen(str)* sizeof(char));
file_data[i] = (struct file_data_struct *) malloc (file_data_size);
(file_data[i]) -> str_len = file_data_size;
strcpy( (file_data[i]) -> nug, str);
strcpy( (file_data[i]) -> cr_date, ctime (&(buf -> st_ctime)) );
strcpy( (file_data[i]) -> l_ch_date, ctime (&(buf -> st_mtime)) );
switch ( (buf -> st_mode) & S_IFMT) {
case S_IFBLK: strcpy ( (file_data[i])->file_type , "block file\n" ); break;
case S_IFCHR: strcpy ( (file_data[i])->file_type , "character file\n" ); break;
case S_IFDIR: strcpy ( (file_data[i])->file_type , "dir\n" ); break;
case S_IFIFO: strcpy ( (file_data[i])->file_type , "FIFO\n" ); break;
case S_IFLNK: strcpy ( (file_data[i])->file_type , "link file\n" ); break;
case S_IFREG: strcpy ( (file_data[i])->file_type , "reg file\n" ); break;
case S_IFSOCK: strcpy ( (file_data[i])->file_type , "socket\n" ); break;
default: strcpy ( (file_data[i])->file_type , "unknown\n" ); break;
}
(file_data[i])->file_size = buf -> st_size;
perm = get_perm(buf -> st_mode);
strcpy( (file_data[i])->perm, perm);
free (user);
free (group);
free (perm);
return;
}
static void restore_current_video(void)
{
if (!config.vga)
return;
/* After all that fun up there, get permissions and save/restore states */
if (video_initialized) {
debug_vid("Restoring dosemu_regs[%d]\n", current_console);
get_perm();
#ifdef WANT_DUMP_VIDEO
dump_video();
#endif
restore_vga_state(dosemu_regs);
}
}
/*
* This function assumes cur is 8 bytes aligned, stride is 16 bytes
* aligned and ref is unaligned
*/
unsigned long
sad8_altivec(const vector unsigned char *cur,
const vector unsigned char *ref,
unsigned long stride)
{
vector unsigned char t1, t2, t3, t4, t5, tp;
vector unsigned int sad;
vector signed int sumdiffs;
vector unsigned char perm_cur;
vector unsigned char perm_ref1, perm_ref2;
unsigned long result;
ZERODEF;
#ifdef DEBUG
if (((unsigned long) cur) & 0x7)
fprintf(stderr, "sad8_altivec:incorrect align, cur: %x\n", cur);
// if (((unsigned long)ref) & 0x7)
// fprintf(stderr, "sad8_altivec:incorrect align, ref: %x\n", ref);
if (stride & 0xf)
fprintf(stderr, "sad8_altivec:incorrect align, stride: %x\n", stride);
#endif
perm_cur = get_perm((((unsigned long) cur) >> 3) & 0x01);
perm_ref1 = vec_lvsl(0, (unsigned char *) ref);
perm_ref2 = get_perm(0);
/* initialization */
sad = (vector unsigned int) (ZEROVEC);
stride >>= 4;
/* perform sum of differences between current and previous */
SAD8();
SAD8();
SAD8();
SAD8();
/* sum all parts of difference into one 32 bit quantity */
sumdiffs = vec_sums((vector signed int) sad, (vector signed int) ZEROVEC);
/* copy vector sum into unaligned result */
sumdiffs = vec_splat(sumdiffs, 3);
vec_ste(sumdiffs, 0, (int *) &result);
return (result);
}
static qeo_policy_perm_t on_policy_update(const qeo_policy_identity_t *identity,
int *policy_updates,
bool reverse)
{
qeo_policy_perm_t perm = QEO_POLICY_DENY;
if (NULL == identity) {
/* end-of-update */
sem_post(&_pol_sync);
}
else {
int64_t uid = qeo_policy_identity_get_uid(identity);
perm = get_perm(uid, reverse);
(*policy_updates)++;
}
return perm;
}
static void OURpermuteX(double *data,
struct lowhigh *result,
int n)
{
register int i, dummy;
const int *pptr;
dummy = n / 2;
pptr = get_perm(n);
for ( i = 0 ; i < dummy; i ++)
{
result->low = data[*pptr];
result->high = data[*(pptr+dummy)];
result++; pptr++;
}
}
void
receive_data (void)
{
unsigned int count;
u_short perm;
char *buffer;
int bufsize;
int fd;
int len, len2;
int error;
char exists;
int readsize;
if (debug)
diag("receiving data");
if ((tempmode&SEND_OVER) == 0)
exists = 0;
else if ( ! get_exists ( &exists ) )
efatal("server read failed");
if (debug)
diag("exists %d", exists);
if (exists) {
if ( ! get_perm ( &perm ) )
efatal("server read failed");
if ( ! get_count ( &count ) )
efatal("server read failed");
} else {
perm = 0600;
count = 0;
}
concat ( temppath, sizeof(temppath), tempdir, "/", tempfile, NULL );
tempfile = temppath;
if (debug) {
diag("perm %#o, count %d", perm, count);
diag("d: %s f: %s p: %s", tempdir, tempfile, temppath );
}
fd = open ( tempfile, O_CREAT | O_RDWR, 0600 );
if (debug)
diag("tempfile %s", tempfile);
if (fchmod(fd, (mode_t) (perm & ( S_IRWXU | S_IRWXG | S_IRWXO ) ) ) < 0)
efatal("fchmod failed");
if (!exists)
(void) unlink(tempfile);
if (count == 0) {
(void) close(fd);
return;
}
/*
* should check for space on disk, but could be expensive and unreliable
*/
if ((bufsize = count) > 10*1024)
buffer = (char *) malloc(bufsize = 10*1024);
else
buffer = (char *) malloc(bufsize);
if (buffer == NULL)
fatal("malloc failed");
while (count != 0) {
if (debug)
diag("loop count %d", count);
if ( count > bufsize )
readsize = bufsize;
else
readsize = count;
/* if */
get_buffer ( buffer, &len, readsize, fd );
if ((len2 = write(fd, buffer, len)) != len) {
error = errno;
(void) close(fd);
(void) unlink(tempfile);
(void) rmdir(tempdir);
errno = error;
efatal("write", error);
}
count -= len;
if (count < bufsize)
bufsize = count;
}
if (close(fd) < 0) {
error = errno;
(void) unlink(tempfile);
(void) rmdir(tempdir);
errno = error;
efatal("close");
}
(void) free(buffer);
if (debug)
diag("transfer complete");
} /* end receive_data */
int _intervalGetWhitelist(void* arg, int type) {
uint32_t next_tag = -1;
uint32_t wl_num_tag_temp = 0;
uint32_t whitelist_tag = -1;
// uint32_t whitelist_element_num = -1;
char* file_name = server.white_file;
perm_t* w_list = NULL;
whitelist_tag = wl_num_tag >> (sizeof(uint32_t) * 8 - WL_TAG_BITS);
// whitelist_element_num = (wl_num_tag << WL_TAG_BITS) >> WL_TAG_BITS;
if(whitelist_tag == 0) {
w_list = redis_w_list.whitelist_switch;
next_tag = 1;
} else if(whitelist_tag == 1) {
w_list = redis_w_list.whitelist;
next_tag = 0;
}
if (check_white_file(file_name) != -1) {
FILE *white_list_fd = fopen(file_name,"r");
if(white_list_fd == NULL) {
redisLog(REDIS_WARNING,"Failed to open the whitelist file[%s]!", file_name);
return -1;
} else {
char buf[40];
uint32_t cnt = 0;
bzero(buf,40);
while(fgets(buf, sizeof(buf), white_list_fd)) {
if(strchr("\n\r#", *buf))
continue;
if(cnt >= WHITELIST_MAX_NUMS) {
redisLog(REDIS_WARNING,"the number of ip in file [%s] is more than iplist_max, [max:%d]",
file_name, WHITELIST_MAX_NUMS);
break;
}
char* ptr = strpbrk(buf, "\n\r");
if(ptr)
*ptr = '\0';
ptr = strpbrk(buf, " \t");
if(!ptr) {
redisLog(REDIS_WARNING,"configure bad format[egg: ip rw]");
continue;
} else {
*ptr = '\0';
w_list[cnt].ip = inet_network(buf);
char perm = get_perm(++ptr);
w_list[cnt].perm = perm;
redisLog(REDIS_NOTICE,"ip: %s, perm str: %s, perm:%d", buf, ptr, perm);
}
cnt++;
}
fclose(white_list_fd);
qsort(w_list, cnt, sizeof(perm_t), compare);
wl_num_tag_temp = (next_tag << (sizeof(uint32_t) * 8 - WL_TAG_BITS)) | cnt;
wl_num_tag = wl_num_tag_temp;
redisLog(REDIS_NOTICE,"whitelist [%s] updated, tag: %d, elements_num:%d", file_name, next_tag, cnt);
}
}
return 0;
}
