러스트가 c 대체 불간응한 EU

나르시 · 2025.07.23 15:00:35

러스트로는 이런거 못 짠다. ㅎㅎㅎ

러빨러들한테 속지 마라

// -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 2; tab-width: 2 -*-

/*

c-loop.c

This file is part of Clair.

Unauthorized copying of this software, via any medium is strictly prohibited.

Proprietary and confidential.

Written by Hodong Kim <hodong@nimfsoft.art>

*/

#if defined(__FreeBSD__) || defined(__OpenBSD__)

#include <sys/param.h>

#include <sys/event.h>

#ifdef __FreeBSD_version

#if __FreeBSD_version >= 1400000

#define __C_TIMER_FD__

#include <sys/timerfd.h>

#endif

#elif defined(__linux__)

#define _POSIX_C_SOURCE 199309L // CLOCK_MONOTONIC

#define __C_TIMER_FD__

#include <sys/timerfd.h>

#include <sys/epoll.h>

#endif

#include "c-loop.h"

#include "c-mem.h"

#include <stdlib.h>

#include <unistd.h>

#include "c-log.h"

#include <errno.h>

#include <string.h>

#include <assert.h>

static CLoop* c_loop;

CSource* c_source_new ()

{

CSource* source = c_calloc (1, sizeof (CSource));

return source;

}

void c_source_free (CSource* source)

{

free (source);

}

CLoop* c_loop_get_default ()

{

if (!c_loop)

c_loop = c_loop_new ();

return c_loop;

}

static uintptr_t idle_key_hash (const uintptr_t* key, uint32_t seed)

{

return c_murmur3_32 ((const uint8_t*) key, 2 * sizeof (uintptr_t), seed);

}

static bool idle_key_equal (const uintptr_t* a, const uintptr_t* b)

{

return !memcmp (a, b, 2 * sizeof (uintptr_t));

}

static void idle_key_free (void* key)

{

free (key);

}

CLoop* c_loop_new ()

{

#if defined(__FreeBSD__) || defined(__OpenBSD__)

int fd = kqueue ();

#elif defined __linux__

int fd = epoll_create1 (EPOLL_CLOEXEC);

#else

#error "This platform is not supported"

#endif

if (fd == -1)

{

c_log_warning ("%s", strerror (errno));

return nullptr;

}

CLoop* loop = c_calloc (1, sizeof (CLoop));

loop->timeout = -1;

loop->timeout_idle = 250;

loop->capa = 4;

#if defined(__FreeBSD__) || defined(__OpenBSD__)

loop->kq = fd;

loop->events = c_calloc (1, loop->capa * sizeof (struct kevent));

#elif defined __linux__

loop->epfd = fd;

loop->events = c_calloc (1, loop->capa * sizeof (struct epoll_event));

#else

#error "This platform is not supported"

#endif

loop->sources = c_hash_map_new (c_ptr_hash, c_ptr_equal, nullptr, nullptr);

loop->idles = c_hash_map_new ((CHashFunc) idle_key_hash,

(CEqualFunc) idle_key_equal,

(CFreeFunc) idle_key_free,

nullptr);

return loop;

}

void c_loop_free (CLoop* loop)

{

if (!loop)

return;

c_hash_map_free (loop->idles);

c_hash_map_free (loop->sources);

#if defined(__FreeBSD__) || defined(__OpenBSD__)

free (loop->events);

close (loop->kq);

#elif defined __linux__

free (loop->events);

close (loop->epfd);

#else

#error "This platform is not supported"

#endif

free (loop);

}

void c_loop_quit (CLoop* loop)

{

loop->run = false;

}

int c_loop_iteration (CLoop* loop)

{

loop->depth++;

// dispatch pending events

CHashMapIter iter;

c_hash_map_iter_init (&iter, loop->sources);

CSource* source;

while (c_hash_map_iter_next (&iter, NULL, (void**) &source))

if (source->pending && source->pending (source) && source->dispatch)

{

source->dispatch (source);

loop->depth--;

return 1;

}

int timeout;

if (loop->idles && c_hash_map_size (loop->idles))

{

if (loop->timeout > -1)

timeout = C_MIN (loop->timeout, loop->timeout_idle);

else

timeout = loop->timeout_idle;

}

else

{

timeout = loop->timeout;

}

int retval;

do {

#if defined(__FreeBSD__) || defined(__OpenBSD__)

struct timespec* ts;

struct timespec ts2;

if (timeout == -1)

{

ts = nullptr;

}

else

{

ts2.tv_sec = timeout * 1000000 / 1000000000;

ts2.tv_nsec = timeout * 1000000 % 1000000000;

ts = &ts2;

}

loop->n_revents = kevent (loop->kq, nullptr, 0, loop->events, loop->n_events, ts);

#elif defined __linux__

loop->n_revents = epoll_wait (loop->epfd, loop->events, loop->n_events, timeout);

#else

#error "This platform is not supported"

#endif

retval = loop->n_revents;

} while (loop->n_revents == -1 && errno == EINTR && loop->run);

while (loop->n_revents > 0)

{

loop->n_revents--;

int i = loop->n_revents;

short revents = 0;

#if defined(__FreeBSD__) || defined(__OpenBSD__)

if (loop->events[i].flags & EV_EOF)

revents |= POLLHUP;

if (loop->events[i].flags & EV_ERROR)

revents |= POLLERR;

if (loop->events[i].filter == EVFILT_READ)

revents |= POLLIN;

else if (loop->events[i].filter == EVFILT_WRITE)

revents |= POLLOUT;

#elif defined(__linux__)

if (loop->events[i].events & EPOLLHUP)

revents |= POLLHUP;

if (loop->events[i].events & EPOLLERR)

revents |= POLLERR;

if (loop->events[i].events & EPOLLIN)

revents |= POLLIN;

else if (loop->events[i].events & EPOLLOUT)

revents |= POLLOUT;

#else

#error "This platform is not supported"

#endif

if (revents)

{

if ((source = c_hash_map_lookup (loop->sources,

#if defined(__FreeBSD__) || defined(__OpenBSD__)

C_INT_TO_VOIDP (loop->events[i].ident))))

#elif defined(__linux__)

C_INT_TO_VOIDP (loop->events[i].data.fd))))

#else

#error "This platform is not supported"

#endif

{

source->revents = revents;

if (source->dispatch)

source->dispatch (source);

}

if (loop->depth == 1 && loop->idles && c_hash_map_size (loop->idles))

{

uintptr_t* key;

void* user_data;

c_hash_map_iter_init (&iter, loop->idles);

while (c_hash_map_iter_next (&iter, (void**) &key, &user_data))

{

CCallback1 callback = (CCallback1) key[0];

callback (user_data);

}

loop->depth--;

return retval;

}

bool c_loop_run (CLoop* loop)

{

loop->run = true;

while (loop->run)

{

if (c_loop_iteration (loop) == -1)

{

if (errno == EINTR)

c_log_info ("%s", strerror (errno));

else

c_log_critical ("%s", strerror (errno));

return false;

}

return true;

}

void c_loop_add_source (CLoop* loop, CSource* source)

{

if (source->fd < 0)

{

c_log_warning ("c_loop_add_source failed: source->fd: %d", source->fd);

return;

}

#if defined(__FreeBSD__) || defined(__OpenBSD__)

struct kevent kevents[2];

int status;

int n_events = 0;

if (source->events & POLLIN)

{

EV_SET (&kevents[n_events], source->fd, EVFILT_READ, EV_ADD, 0, 0, 0);

n_events++;

}

if (source->events & POLLOUT)

{

EV_SET (&kevents[n_events], source->fd, EVFILT_WRITE, EV_ADD, 0, 0, 0);

n_events++;

}

status = kevent (loop->kq, kevents, n_events, NULL, 0, NULL);

if (status == -1)

{

c_log_warning ("kevent (loop->kq, kevents, %d, NULL, 0, NULL) failed: %s",

n_events, strerror (errno));

return;

}

#elif defined __linux__

struct epoll_event eevent = { 0 };

int status;

int n_events = 1;

eevent.events = 0;

eevent.data.fd = source->fd;

if (source->events & POLLIN)

eevent.events |= EPOLLIN;

if (source->events & POLLOUT)

eevent.events = EPOLLOUT;

status = epoll_ctl (loop->epfd, EPOLL_CTL_ADD, source->fd, &eevent);

if (status == -1)

{

c_log_warning ("epoll_ctl EPOLL_CTL_ADD %d failed: %s",

source->fd, strerror (errno));

return;

}

#else

#error "This platform is not supported"

#endif

#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__linux__)

loop->n_events += n_events;

if (loop->n_events == loop->capa)

#else

#error "This platform is not supported"

#endif

{

loop->capa *= 2;

#if defined(__FreeBSD__) || defined(__OpenBSD__)

loop->events = c_realloc (loop->events,

loop->capa * sizeof (struct kevent));

#elif defined __linux__

loop->events = c_realloc (loop->events,

loop->capa * sizeof (struct epoll_event));

#else

#error "This platform is not supported"

#endif

}

c_hash_map_insert (loop->sources, C_INT_TO_VOIDP (source->fd), source);

}

void c_loop_remove_source (CLoop* loop, CSource* source)

{

int status;

int n_events = 0;

#if defined(__FreeBSD__) || defined(__OpenBSD__)

struct kevent kevents[2];

if (source->events & POLLIN)

{

EV_SET (&kevents[n_events], source->fd, EVFILT_READ, EV_DELETE, 0, 0, 0);

n_events++;

}

if (source->events & POLLOUT)

{

EV_SET (&kevents[n_events], source->fd, EVFILT_WRITE, EV_DELETE, 0, 0, 0);

n_events++;

}

status = kevent (loop->kq, kevents, n_events, NULL, 0, NULL);

if (status == -1)

{

c_log_warning ("kevent (loop->kq, kevents, 1, NULL, 0, NULL) failed: %s",

strerror (errno));

return;

}

for (int i = 0; i < loop->n_revents; i++)

{

if (loop->events[i].ident == source->fd)

{

loop->events[i].ident = -1;

loop->events[i].filter = 0;

loop->events[i].flags = 0;

}

#elif defined __linux__

n_events = 1;

status = epoll_ctl (loop->epfd, EPOLL_CTL_DEL, source->fd, nullptr);

if (status == -1)

{

c_log_warning ("epoll_ctl EPOLL_CTL_DEL %d failed: %s",

source->fd, strerror (errno));

return;

}

for (int i = 0; i < loop->n_revents; i++)

{

if (loop->events[i].data.fd == source->fd)

{

loop->events[i].events = 0;

loop->events[i].data.fd = -1;

break;

}

#else

#error "This platform is not supported"

#endif

loop->n_events -= n_events;

if (loop->n_events < loop->capa / 4)

{

loop->capa /= 2;

#if defined(__FreeBSD__) || defined(__OpenBSD__)

loop->events = c_realloc (loop->events,

loop->capa * sizeof (struct kevent));

#elif defined __linux__

loop->events = c_realloc (loop->events,

loop->capa * sizeof (struct epoll_event));

#else

#error "This platform is not supported"

#endif

}

c_hash_map_remove (loop->sources, C_INT_TO_VOIDP (source->fd));

}

static void fd_dispatch (CSource* source)

{

if (source->callback)

{

CFdCallback callback = (CFdCallback) source->callback;

callback (source->fd, source->revents, source->user_data);

}

void c_loop_add_fd (CLoop* loop,

int fd,

short events,

CFdCallback callback,

void* user_data)

{

if (fd < 0)

{

c_log_warning ("c_loop_add_fd failed: fd: %d", fd);

return;

}

CSource* source = c_source_new ();

source->fd = fd;

source->events = events;

source->dispatch = fd_dispatch;

source->callback = (CCallback) callback;

source->user_data = user_data;

c_loop_add_source (loop, source);

}

void c_loop_remove_fd (CLoop* loop, int fd)

{

if (fd < 0)

{

c_log_warning ("c_loop_remove_fd failed: %d", fd);

return;

}

CSource* source = c_hash_map_lookup (loop->sources, C_INT_TO_VOIDP (fd));

c_loop_remove_source (loop, source);

c_source_free (source);

}

void c_loop_mod_fd (CLoop* loop, int fd, short events)

{

CSource* source = c_hash_map_lookup (loop->sources, C_INT_TO_VOIDP (fd));

#if defined(__FreeBSD__) || defined(__OpenBSD__)

struct kevent kevents[2];

int i = 0;

if ((source->events & POLLIN) - (events & POLLIN) > 0)

{

EV_SET (&kevents[i], fd, EVFILT_READ, EV_DELETE, 0, 0, 0);

i++;

}

else if ((source->events & POLLIN) - (events & POLLIN) < 0)

{

EV_SET (&kevents[i], fd, EVFILT_READ, EV_ADD | EV_CLEAR, 0, 0, 0);

i++;

}

if ((source->events & POLLOUT) - (events & POLLOUT) > 0)

{

EV_SET (&kevents[i], fd, EVFILT_WRITE, EV_DELETE, 0, 0, 0);

i++;

}

else if ((source->events & POLLOUT) - (events & POLLOUT) < 0)

{

EV_SET (&kevents[i], fd, EVFILT_WRITE, EV_ADD | EV_CLEAR, 0, 0, 0);

i++;

}

if (i > 0)

{

int status = kevent (loop->kq, kevents, i, NULL, 0, NULL);

if (status == -1)

{

c_log_warning ("kevent (loop->kq, kevents, i, NULL, 0, NULL) failed: %s",

i, strerror (errno));

}

#elif defined __linux__

struct epoll_event eevent = { 0 };

if (events & POLLIN)

eevent.events = EPOLLIN;

if (events & POLLOUT)

eevent.events = EPOLLOUT;

eevent.data.fd = fd;

int status = epoll_ctl (loop->epfd, EPOLL_CTL_MOD, fd, &eevent);

if (status == -1)

c_log_warning ("epoll_ctl EPOLL_CTL_MOD %d %u failed: %s",

fd, eevent.events, strerror (errno));

#else

#error "This platform is not supported"

#endif

source->events = events;

}

void* c_loop_add_idle (CLoop* loop, CCallback1 callback, void* user_data)

{

uintptr_t* key = c_malloc (2 * sizeof (uintptr_t));

key[0] = (uintptr_t) callback;

key[1] = (uintptr_t) user_data;

c_hash_map_insert (loop->idles, key, user_data);

return callback;

}

void c_loop_remove_idle (CLoop* loop, CCallback1 callback, void* user_data)

{

uintptr_t key[2] = { (uintptr_t) callback, (uintptr_t) user_data };

c_hash_map_remove (loop->idles, key);

}

static void timer_dispatch (CSource* source)

{

c_log_debug ("timer_dispatch: source->fd: %d", source->fd);

int status;

#if defined(__C_TIMER_FD__)

uint64_t n_expirations;

do {

status = read (source->fd, &n_expirations, sizeof (uint64_t));

} while (status == -1 && errno == EINTR);

#else

struct kevent event;

status = kevent (source->fd, NULL, 0, &event, 1, NULL);

#endif

if (status == -1)

{

c_log_critical ("%s", strerror (errno));

return;

}

else if (status > 0 && source->callback)

{

CCallback1 callback = (CCallback1) source->callback;

callback (source->user_data);

}

return;

}

int c_loop_add_timer (CLoop* loop, int ms, CCallback1 callback, void* user_data)

{

#if defined(__C_TIMER_FD__)

int fd = timerfd_create (CLOCK_MONOTONIC, TFD_CLOEXEC);

#else

int fd = kqueue ();

#endif

if (fd == -1)

{

c_log_warning ("%s", strerror (errno));

return -1;

}

if (!c_loop_mod_timer (loop, fd, ms))

{

close (fd);

return -1;

}

CSource* source = c_source_new ();

source->fd = fd;

source->events = POLLIN;

source->dispatch = timer_dispatch;

source->callback = (CCallback) callback;

source->user_data = user_data;

c_loop_add_source (loop, source);

return fd;

}

void c_loop_remove_timer (CLoop* loop, int fd)

{

if (fd < 0)

{

c_log_warning ("fd is less than 0: i%d", fd);

return;

}

CSource* source = c_hash_map_lookup (loop->sources, C_INT_TO_VOIDP (fd));

if (source)

{

#if defined(__C_TIMER_FD__)

struct itimerspec ts = { { 0, 0 }, { 0, 0 } };

if (timerfd_settime (fd, 0, &ts, nullptr))

c_log_warning ("%s", strerror (errno));

#else

struct kevent event;

EV_SET (&event, fd, EVFILT_TIMER, EV_DELETE | EV_DISABLE, 0, 0, 0);

int status = kevent (source->fd, &event, 1, NULL, 0, NULL);

if (status == -1)

{

c_log_warning ("kevent (%d, &event, 1, NULL, 0, NULL) failed: %s", fd,

strerror (errno));

}

#endif

c_loop_remove_source (loop, source);

c_source_free (source);

if (fd > -1)

close (fd);

}

bool c_loop_mod_timer (CLoop* loop, int fd, int ms)

{

if (fd < 0)

{

c_log_warning ("fd < 0: %d", fd);

return false;

}

#if defined(__C_TIMER_FD__)

long nsec;

if (ms > 0)

nsec = (long) ms * 1000000;

else if (ms == 0)

nsec = 1;

else

nsec = 0;

struct itimerspec its;

// 1000000000 ns = 1 sec

its.it_value.tv_sec = nsec / 1000000000;

its.it_value.tv_nsec = nsec % 1000000000;

its.it_interval.tv_sec = its.it_value.tv_sec;

its.it_interval.tv_nsec = its.it_value.tv_nsec;

if (timerfd_settime (fd, 0, &its, nullptr))

{

c_log_warning ("timerfd_settime failed: %s", strerror (errno));

return false;

}

#else

struct kevent event;

int status;

if (ms < 0)

EV_SET (&event, fd, EVFILT_TIMER, EV_ADD | EV_DISABLE, 0, 0, 0);

else

EV_SET (&event, fd, EVFILT_TIMER, EV_ADD | EV_ENABLE, 0, ms, 0);

status = kevent (fd, &event, 1, NULL, 0, NULL);

if (status == -1)

{

c_log_warning ("kevent (fd, &event, 1, NULL, 0, NULL) failed: %s",

strerror (errno));

return false;

}

#endif

return true;

}

번호	제목	글쓴이	작성일	조회	추천
설문	모태 솔로도 구제해 줄 것 같은 연애 고수 스타는?	운영자	25/07/21	-	-
2874658	확실히 애바가 우울증 치료효과가 있네 - 레딧 글	ㅇㅇ(183.101)	07.25	25	0
2874657	지금도 송지훈형 모델그대로네요예	신비한티비서프라이즈(121.147)	07.25	27	0
2874656	유니티 씨발련아 [4]	루도그담당(58.239)	07.25	38	0
2874655	민생지원금으로 주식을 어떻게 산다는 거죠? [1]	발명도둑잡기(118.216)	07.25	25	0
2874654	수리할 권리를 투쟁으로 쟁취해야 한다	발명도둑잡기(118.216)	07.25	15	0
2874652	슬줌마 슬카스 [12]	♥팬티스타킹냥덩♥	07.25	59	0
2874651	끙야대신 뿡야만.. 힘둘당.. [1]	♥팬티스타킹냥덩♥	07.25	28	0
2874650	확실히 질 좋은 수면을 위해서는 카페인 끊고 술마시면 안됨 [4]	♥팬티스타킹냥덩♥	07.25	36	0
2874649	4시간 넘게 잔변느낌으로 괴롭당..	♥팬티스타킹냥덩♥	07.25	20	0
2874647	뭔가 이상해 [7]	개멍청한유라	07.25	55	0
2874645	재명지원금으로 주식이나 더 사야겟다 [2]	헬마스터	07.25	38	0
2874644	재명지원금이라고 할인에 먹을거 더 퍼주는데 [1]	헬마스터	07.25	29	0
2874638	옛날에 skt 직원한태 5g교육받은적 있었는데 [2]	밀우	07.25	35	0
2874636	냥덩 만화상 이 만화가 대단하당⭐ 13회 수상작 [1]	♥팬티스타킹냥덩♥	07.25	29	0
2874635	프랑스, 9월 팔레스타인 국가 승인	발명도둑잡기(118.216)	07.25	16	0
2874634	ide는 다 웹으로 가겠네 [4]	뉴진파	07.25	55	0
2874633	노동자 연쇄살인 독과점 기업 파리바게뜨 SPC, 이재명 대통령 방문	발명도둑잡기(118.216)	07.25	37	0
2874628	파시스트 정당 국민의힘을 지배하는 기본 심리는 사도마조히즘 [2]	발명도둑잡기(118.216)	07.25	27	0
2874625	고죠사또롱 vs 학교괴담 여주	♥팬티스타킹냥덩♥	07.25	21	0
2874624	도로롱.. 드디어 내일이야.. 기다려줘.. [3]	♥팬티스타킹냥덩♥	07.25	37	0
2874623	지하철역에 칼잡이 또 떴다고한다 [2]	헬마스터	07.25	46	0
2874622	정부, 전국민 SW 패치 자동 업데이트 추진…해킹 취약점 대응	발명도둑잡기(118.216)	07.25	33	1
2874620	후우 오랜만에 수학 공부하니까 [4]	어린이노무현	07.25	56	0
2874618	주작기는 무료로 되겠지. 근데 도배기랑 역류기는 글 한페이지 도배를 [1]	ㅆㅇㅆ(124.216)	07.25	59	0
2874617	정확히정리해줌 무료프록시되는거:존재함 하지만 소수 유료프록시:안정 [4]	ㅇㅇ(106.102)	07.25	90	0
2874616	아니, 그냥 단순하게 도배기랑 역류기 원리만 봐도 유료프록시인거 알텐데 [1]	ㅆㅇㅆ(124.216)	07.25	32	0
2874615	무료프록시도 되는건존재함 애옹이한테물어봤었음 [2]	ㅇㅇ(106.102)	07.25	63	0
2874614	무료프록시잘만되는데 저능아라 만들어본적도없으면서 뇌피셜 ㅆㅎㅌㅊ노	ㅇㅇ(118.37)	07.25	25	0
2874612	진짜 굳이 커뮤하나때문에 주작기까지쳐만드는새끼들은ㅇㅇㅇ [2]	ㅇㅇ(106.102)	07.25	41	1
2874611	지금 도배기랑 역류기 만드는 애들한테 사면 다 유료 프록시하라는데 [1]	ㅆㅇㅆ(124.216)	07.25	28	0
2874610	외모가 떨어지는 사람이 더 공격적이라는 심리학 연구 있나 [1]	발명도둑잡기(118.216)	07.25	24	0
2874609	초전도드래곤 행성이한테 물어보면되는데 왜지들끼리 쳐싸우노 [2]	ㅇㅇ(211.36)	07.25	53	0
2874608	더워서 밖엘 못나가겠다..ㅇㅅㅇ	헤르 미온느	07.25	14	0
2874607	무료프록시잘되는데 저능아고 프알못이라 만들어본적도없으니 [1]	ㅇㅇ(118.37)	07.25	30	0
2874606	병신들 자강두천 또시작했노 [1]	ㅇㅇ(106.102)	07.25	22	0
2874605	디시인사이드 도배는 https 요청인데 뭔 씨발 무료 프록시가 되고	ㅆㅇㅆ(124.216)	07.25	34	0
2874604	금쪽이 처음나올때부터 ㅈ같았는데 볼게없어서 금쪽이를 보게됨 [1]	뒷통수한방(1.213)	07.25	21	0
2874603	무료프록시잘되는데 능력없는 저능아라 만들지도못하네 [4]	ㅇㅇ(118.37)	07.25	48	0
2874602	나님 애니보면서 주무싶니댱⭐+	♥팬티스타킹냥덩♥	07.25	19	0
2874601	https 기반 프록시는 대부분 유료 프록시인데 뭔 무료가 돼	ㅆㅇㅆ(124.216)	07.25	27	0
2874600	이게 사실이면.. 빅브라더 완성인데?	손발이시립디다	07.25	23	0
2874599	ㅆㅇㅆ징:지가능력없고저능아라 못만드는걸 프록시탓만함 [8]	ㅇㅇ(118.37)	07.25	77	0
2874598	중국이 틱톡으로 힙합 트렌드 좌우? [1]	발명도둑잡기(118.216)	07.25	23	0
2874597	지금 도배 역류기 https 써야해서 유료 프록시일텐데	ㅆㅇㅆ찡	07.25	33	0
2874596	왜 불렁~ 배 불렁~ 배 뽈록~⭐	♥팬티스타킹냥덩♥	07.25	27	0
2874595	이대통령 "12시간 4일연속 이게 가능하냐?"	프갤러(220.85)	07.25	23	0
2874594	석열이란 이름 자체가 10만원 전국민 지원금 줄 운명이다	발명도둑잡기(118.216)	07.25	15	0
2874591	국가보안법과 음악 관련 영화 [1]	발명도둑잡기(118.216)	07.25	22	0
2874587	신태일씨 브베 떡방송 보며 탄식햇던게 엊그제같은데	헬마스터	07.25	40	0
2874585	믿기지 않는 이야기지만 2025년 한국에서 벌어지는 일입니다	발명도둑잡기(118.216)	07.25	15	0
뉴스	조윤희 “이상형 만나”…이동건과 이혼 5년 만에 ‘기쁜 소식’	디시트렌드	07.24

최근 방문

즐겨찾기

즐겨찾기 갤러리

이미지 올리기 이용안내

갤러리 이슈박스, 최근방문 갤러리

연관 갤러리

개념글 리스트

차단하기

[프로그래밍 갤러리]

갤러리 본문 영역

추천 비추천

댓글 영역

① NFT 발행

② NFT 구매

하단 갤러리 리스트 영역

왼쪽 컨텐츠 영역

갤러리 리스트 영역

페이지 이동

오른쪽 컨텐츠 영역

알림 설정

알림

디시콘 리스트

디시콘

디시콘 검색결과(0)

인기 디시콘