int signal_init(void)
{
struct sigaction action;
ft_memset(&action, 0, sizeof(action));
action.sa_sigaction = &signal_handler;
action.sa_flags = SA_SIGINFO | SA_RESTART;
sigaction(SIGQUIT, &action, NULL);
sigaction(SIGINT, &action, NULL);
sigaction(SIGTSTP, &action, NULL);
sigaction(SIGWINCH, &action, NULL);
return (0);
}
static int ft_test_memset2(char *str, char *str2, int n)
{
int res;
res = 0;
ft_memset(str, '{', n);
memset(str2, '{', n);
printf("After : \"%s\" , \"%s\"", str, str2);
if (strcmp_bsd(str, str2))
++res;
ft_print_status(res);
return (res);
}
char *modetostr(mode_t st_mode)
{
char *str;
str = (char*)malloc(sizeof(char) * 12);
ft_memset(str, '-', 10);
str[10] = '\0';
str[0] = mode(st_mode);
modeusr(st_mode, str);
modegrp(st_mode, str);
modeoth(st_mode, str);
return (str);
}
static int copy_buf(char *buf, char **line, int is_reading)
{
char endbuf;
int buffsize;
int linesize;
buffsize = size_buf(buf);
linesize = ft_strlen(*line);
if (!(*line = ft_memrealloc(*line, linesize, linesize + buffsize + 1)))
return (-1);
if (!ft_memcpy(*line + linesize, buf, buffsize))
return (-1);
if (buffsize != GNL_BUFF_SIZE)
{
endbuf = buf[buffsize];
if (!ft_memmove(buf, buf + buffsize + 1, GNL_BUFF_SIZE - buffsize - 1)
|| !ft_memset(buf + GNL_BUFF_SIZE - buffsize - 1, 0, buffsize + 1))
return (-1);
return ((is_reading || *buf || endbuf == '\n') ? 1 : 0);
}
return ((!ft_memset(buf, 0, buffsize)) ? -1 : 0);
}
static void ft_flag_zero(char **regex_printed, char specifier)
{
int i;
i = -1;
while ((*regex_printed)[++i] == ' ')
(*regex_printed)[i] = '0';
if (specifier == 'p' && !ft_strcmp(&(*regex_printed)[i], "0x0"))
*regex_printed = ft_strjoin(&(*regex_printed)[i],
ft_memset(ft_strnew(i + 1), '0', i));
((*regex_printed)[i] == '-' && i > 0) ? ((*regex_printed)[0] = '-') : (0);
((*regex_printed)[i] == '-' && i > 0) ? ((*regex_printed)[i] = '0') : (0);
}
static void set_pseudogram(char *pseudogram, struct pseudo_header *psh, struct tcphdr *header, int len, struct ip *ip_header, char *device)
{
t_flag *spoof = get_flag("spoof");
psh->source_address = (spoof && spoof->value) ? inet_addr(spoof->value) : inet_addr(device);
psh->dest_address = ip_header->ip_dst.s_addr;
psh->placeholder = 0;
psh->protocol = IPPROTO_TCP;
psh->length = htons(sizeof(struct tcphdr));
ft_memset(pseudogram, 0, len);
ft_memcpy(pseudogram, psh, sizeof(struct pseudo_header));
ft_memcpy(pseudogram + sizeof(struct pseudo_header), header, sizeof(struct tcphdr));
}
char *ft_process_p_width(char *str, t_arg arg)
{
char *strp;
if (arg.flag_minus)
ft_process_p_width_flag_minus(&str, &strp, arg);
else if (arg.flag_zero)
{
if (arg.width > ft_strlen(str))
{
strp = ft_memalloc(arg.width - ft_strlen(str) + 1);
strp = ft_memset(strp, '0', arg.width - ft_strlen(str));
str = ft_strjoin(str, strp);
}
}
if (arg.width > ft_strlen(str))
{
strp = ft_memalloc(arg.width - ft_strlen(str) + 1);
strp = ft_memset(strp, ' ', arg.width - ft_strlen(str));
str = ft_strjoin(strp, str);
}
return (str);
}
char *ft_strnew(size_t size)
{
char *res;
size++;
res = (char *)malloc(sizeof(char *) * size);
if (res)
{
ft_memset(res, 0, size);
return (res);
}
else
return (NULL);
}
char *ft_char_conv(t_options *stc, unsigned int c)
{
char *end_str;
if (!(end_str = ft_strnew(stc->area ? stc->area : 1)))
return (NULL);
if (stc->area)
{
if (!(stc->fl & FT_LESS))
ft_memset(end_str, ((stc->fl & FT_ZERO) ? '0' : ' '),
stc->area - 1);
end_str[ft_strlen(end_str)] = (char)c;
if ((stc->fl & FT_LESS))
ft_memset(end_str + 1, ' ', stc->area - 1);
stc->sc = stc->area;
}
else
{
*end_str = (char)c;
stc->sc = 1;
}
return (end_str);
}
char *ft_strncpy(char *dest, const char *src, size_t n)
{
size_t i;
i = 0;
ft_memset(dest, '\0', n);
while (src[i] && n > 0)
{
dest[i] = src[i];
i++;
n--;
}
return (dest);
}
int main()
{
char *actual, *expected;
actual = (char *) ft_memalloc(sizeof(*actual) * BUFF_SIZE);
expected = (char *) ft_memalloc(sizeof(*expected) * BUFF_SIZE);
actual = ft_memset(actual, 'K', 8);
expected = memset(expected, 'K', 8);
if (ft_memcmp(actual, expected, 8) == 0)
printf("OK\n");
else
printf("memset ERROR! Expected: %s, actual: %s\n", expected, actual);
return 0;
}
void *ft_realloc(void *ptr, size_t size)
{
void *dup;
dup = ft_memalloc(size);
dup = ft_memset(dup, 0, size);
if (ptr)
{
if (dup)
ft_memcpy(dup, ptr, size);
ft_memdel(&ptr);
}
return (dup);
}
int ft_asprintf(char **ret, const char *format, ...)
{
t_dt data;
ft_memset(&data, 0, sizeof(data));
data.tail = (char *)format;
va_start(data.ap, format);
data.write_method = ft_asprintf_write;
ft_base(&data);
ft_asprintf_write(&data);
va_end(data.ap);
*ret = (char *)data.stream;
return (data.ret - data.less);
}
char *ft_init_key(int a, int b, int c, int d)
{
char *key;
if (!(key = (char *)malloc(sizeof(char) * 5)))
return (NULL);
ft_memset(key, 0, 5);
key[0] = a;
key[1] = b;
key[2] = c;
key[3] = d;
key[4] = '\0';
return (key);
}
t_prts *ft_handle_b_v(t_pmts pmts, t_prts **node, char *res)
{
char *tmp;
size_t len;
len = ft_strlen(res);
tmp = ft_malloc_sz(pmts.value - len);
tmp = ft_memset(tmp, 32, pmts.value - len);
res = pmts.minus ? ft_strjoin_free(res, tmp, 3)
: ft_strjoin_free(tmp, res, 3);
(*node)->str = res;
(*node)->len = ft_strlen(res);
return (*node);
}
void *ft_memalloc(size_t size)
{
void *dest;
if (size <= 0)
return (NULL);
dest = malloc(size);
if (dest == NULL)
return (NULL);
ft_memset(dest, 0, size);
if (dest)
return (dest);
else
return (NULL);
}
void ft_case1_o(char **s, size_t l, t_pmts *p, t_prts **n)
{
char *tmp;
size_t var;
if (p->hash)
p->prec_value -= 1;
var = p->prec_value - l;
tmp = ft_malloc_sz(var);
tmp = ft_memset(tmp, 48, var);
*s = ft_strjoin_free(tmp, *s, 3);
(*n)->len = ft_strlen(*s);
p->prec = 0;
p->prec_value = 0;
}
static char *ft_second(long double nbr)
{
int i;
char *str;
long double nb;
i = 0;
nb = nbr;
while (nb > 0 && nb < 1)
{
i++;
nb = nb * 10;
nb = nb - (long long int)nb;
}
if (!(str = (i > 6) ? ft_strnew(i + 1) : ft_strnew(7)))
return (NULL);
if (i > 6)
str = (char*)ft_memset(str, '0', i + 1);
else
str = (char*)ft_memset(str, '0', 7);
str[0] = '.';
ft_fill_decimal(str, nbr, i);
return (str);
}
char static *ft_preci_b(char *bstr, int size)
{
char *str;
int diff;
diff = size - ft_strlen(bstr);
str = ft_strnew(size);
ft_memset(str, '0', size);
while (str[diff] != '\0')
{
str[diff] = *bstr++;
diff++;
}
return (str);
}
int ft_print_wchar(va_list *list_args, t_args *arg)
{
wchar_t wchar;
wchar = (wchar_t)va_arg(*list_args, wint_t);
ft_memset(arg->conv, '\0', 3);
if (arg->val_field && !arg->val_minus && arg->val_z)
ft_printnchar(arg->field - ft_wcharlen(wchar), '0');
if (arg->val_field && !arg->val_minus && !arg->val_z)
ft_printnchar(arg->field - ft_wcharlen(wchar), ' ');
ft_putwchar(wchar);
if (arg->val_field == 1 && arg->val_minus == 1)
ft_printnchar(arg->field - ft_wcharlen(wchar), ' ');
return (ft_retfield(arg, ft_wcharlen(wchar)));
}
int key(int keycode, t_mlx *mlx)
{
float a;
float b;
mlx->imgview->addr = ft_memset(mlx->imgview->addr, 0, mlx->w * mlx->h * 4
- 1);
mlx->imgmap->addr = ft_memset(mlx->imgmap->addr, 0, mlx->mapw * mlx->maph *
4 - 1);
a = cos(mlx->deg * (PI / 180)) / 4;
b = sin(mlx->deg * (PI / 180)) / 4;
key1(keycode, mlx, a, b);
key2(keycode, mlx, a, b);
key3(keycode, mlx, a, b);
key4(keycode, mlx, a, b);
if (keycode == 53)
str_exit(0, "ESC", mlx);
if (keycode == 0)
mlx->deg -= 5;
if (keycode == 2)
mlx->deg += 5;
draw(mlx);
return (0);
}
char *ft_print_extra(char *format, char **regex_printed,
char specifier, int size_s)
{
int i;
int precision;
int fieldwidth;
char flags[5];
i = -1;
ft_memset(&flags[0], 0, 5);
precision = ft_precision(format, regex_printed, specifier, size_s);
fieldwidth = ft_fieldwidth(format, regex_printed, specifier);
ft_flags(format, specifier, precision, flags);
ft_modif_flags(format, regex_printed, specifier, flags);
return (*regex_printed);
}
int main(int argc, char **argv)
{
t_data e;
if ((argc == 2 || argc == 3) && argv[1] && ft_strstr(argv[1], ".fdf")
&& ft_memset(&e, 0, sizeof(e)))
{
if (argc == 2)
option_case(argv[1], 1);
if (argc == 3)
option_case(argv[1], ft_atoi(argv[2]));
}
else
put_usage_error(argv[0]);
return (0);
}
char *ft_strpad(const char *s, size_t pad_len, char pad_char, t_dir dir)
{
size_t len;
char *pad;
len = ft_strlen(s);
if (pad_len <= len)
return (ft_strdup(s));
pad = ft_strnew(pad_len);
ft_memset(pad, pad_char, pad_len);
if (dir == left)
ft_memcpy(pad + pad_len - len, s, len);
else
ft_memcpy(pad, s, len);
return (pad);
}
t_arc *ft_init_miss(void *start, void *file, t_arc *tmp)
{
t_arc *ret;
ret = (t_arc *)malloc(sizeof(*ret));
if (ret != NULL)
{
ft_memset(ret, '\0', sizeof(*ret));
ret->pos = -1;
ret->off = file - start;
ret->ar_hdr = start + ret->off;
ret->next = NULL;
ret->prev = tmp;
}
return (ret);
}
t_line *ft_create_elem(int fd, char *buf)
{
t_line *ptr;
ptr = (t_line *)malloc(sizeof(t_line));
ptr->read = (char **)malloc(sizeof(char *) * 10000000);
ptr->read[0] = (char *)malloc(sizeof(char) * 10000000);
ptr->read[0] = ft_memset(ptr->read[0], '\0', 10000000);
ptr->fd = fd;
ptr->next = NULL;
ptr->line = 0;
ptr->lasti = 0;
ptr->lastj = 0;
ft_fill_tab(buf, ptr);
return (ptr);
}
int filling(int c, int width)
{
char *str;
int i;
i = 0;
if (width <= 0)
return (0);
if ((str = (char *)malloc(sizeof(char) * width + 1)) == NULL)
return (-1);
str[width] = '\0';
ft_memset(str, c, width);
i += ft_putstr(str);
free(str);
return (i);
}
int get_overf(char **line, char *overflow)
{
char *endl;
endl = ft_strchr(overflow, '\n');
if (endl)
{
*endl = '\0';
*line = ft_strdup(overflow);
ft_memmove(overflow, endl + 1, BUFF_SIZE - (endl - overflow));
return (1);
}
*line = ft_strdup(overflow);
ft_memset(overflow, 0, BUFF_SIZE + 1);
return (0);
}
int read_line(char **buf, int fd)
{
char buffer[BUFF_SIZE + 1];
int read_bytes;
read_bytes = 1;
while (ft_strstr(*buf, "\n") == NULL && read_bytes != 0)
{
if ((read_bytes = read(fd, buffer, BUFF_SIZE)) == -1)
return (-1);
buffer[read_bytes] = '\0';
*buf = ft_strjoin(*buf, buffer);
ft_memset(buffer, 0, read_bytes);
}
return (read_bytes);
}
static void ft_flag_moins(char **regex_printed)
{
char *add;
int i;
i = 0;
while ((*regex_printed)[i] == ' ')
i++;
if (i > 0)
{
add = ft_strjoin(ft_strdup(&(*regex_printed)[i]),
(char*)ft_memset(ft_strnew(i), ' ', i));
free(*regex_printed);
*regex_printed = ft_strdup(add);
free(add);
}
}
