sway: change all sway_log to wlr_log

1 files changed, 25 insertions, 25 deletions

diff --git a/sway/ipc-server.c b/sway/ipc-server.c
index 046e40a8..d2dd881f 100644
--- a/sway/ipc-server.c
+++ b/sway/ipc-server.c
@@ -125,32 +125,32 @@ struct sockaddr_un *ipc_user_sockaddr(void) {
 int ipc_handle_connection(int fd, uint32_t mask, void *data) {
         (void) fd;
         struct sway_server *server = data;
-        sway_log(L_DEBUG, "Event on IPC listening socket");
+        wlr_log(L_DEBUG, "Event on IPC listening socket");
         assert(mask == WL_EVENT_READABLE);
 
         int client_fd = accept(ipc_socket, NULL, NULL);
         if (client_fd == -1) {
-                sway_log_errno(L_ERROR, "Unable to accept IPC client connection");
+                wlr_log_errno(L_ERROR, "Unable to accept IPC client connection");
                 return 0;
         }
 
         int flags;
         if ((flags = fcntl(client_fd, F_GETFD)) == -1
                         || fcntl(client_fd, F_SETFD, flags|FD_CLOEXEC) == -1) {
-                sway_log_errno(L_ERROR, "Unable to set CLOEXEC on IPC client socket");
+                wlr_log_errno(L_ERROR, "Unable to set CLOEXEC on IPC client socket");
                 close(client_fd);
                 return 0;
         }
         if ((flags = fcntl(client_fd, F_GETFL)) == -1
                         || fcntl(client_fd, F_SETFL, flags|O_NONBLOCK) == -1) {
-                sway_log_errno(L_ERROR, "Unable to set NONBLOCK on IPC client socket");
+                wlr_log_errno(L_ERROR, "Unable to set NONBLOCK on IPC client socket");
                 close(client_fd);
                 return 0;
         }
 
         struct ipc_client *client = malloc(sizeof(struct ipc_client));
         if (!client) {
-                sway_log(L_ERROR, "Unable to allocate ipc client");
+                wlr_log(L_ERROR, "Unable to allocate ipc client");
                 close(client_fd);
                 return 0;
         }
@@ -166,12 +166,12 @@ int ipc_handle_connection(int fd, uint32_t mask, void *data) {
         client->write_buffer_len = 0;
         client->write_buffer = malloc(client->write_buffer_size);
         if (!client->write_buffer) {
-                sway_log(L_ERROR, "Unable to allocate ipc client write buffer");
+                wlr_log(L_ERROR, "Unable to allocate ipc client write buffer");
                 close(client_fd);
                 return 0;
         }
 
-        sway_log(L_DEBUG, "New client: fd %d", client_fd);
+        wlr_log(L_DEBUG, "New client: fd %d", client_fd);
         list_add(ipc_client_list, client);
         return 0;
 }
@@ -182,22 +182,22 @@ int ipc_client_handle_readable(int client_fd, uint32_t mask, void *data) {
         struct ipc_client *client = data;
 
         if (mask & WL_EVENT_ERROR) {
-                sway_log(L_ERROR, "IPC Client socket error, removing client");
+                wlr_log(L_ERROR, "IPC Client socket error, removing client");
                 ipc_client_disconnect(client);
                 return 0;
         }
 
         if (mask & WL_EVENT_HANGUP) {
-                sway_log(L_DEBUG, "Client %d hung up", client->fd);
+                wlr_log(L_DEBUG, "Client %d hung up", client->fd);
                 ipc_client_disconnect(client);
                 return 0;
         }
 
-        sway_log(L_DEBUG, "Client %d readable", client->fd);
+        wlr_log(L_DEBUG, "Client %d readable", client->fd);
 
         int read_available;
         if (ioctl(client_fd, FIONREAD, &read_available) == -1) {
-                sway_log_errno(L_INFO, "Unable to read IPC socket buffer size");
+                wlr_log_errno(L_INFO, "Unable to read IPC socket buffer size");
                 ipc_client_disconnect(client);
                 return 0;
         }
@@ -219,13 +219,13 @@ int ipc_client_handle_readable(int client_fd, uint32_t mask, void *data) {
         // Should be fully available, because read_available >= ipc_header_size
         ssize_t received = recv(client_fd, buf, ipc_header_size, 0);
         if (received == -1) {
-                sway_log_errno(L_INFO, "Unable to receive header from IPC client");
+                wlr_log_errno(L_INFO, "Unable to receive header from IPC client");
                 ipc_client_disconnect(client);
                 return 0;
         }
 
         if (memcmp(buf, ipc_magic, sizeof(ipc_magic)) != 0) {
-                sway_log(L_DEBUG, "IPC header check failed");
+                wlr_log(L_DEBUG, "IPC header check failed");
                 ipc_client_disconnect(client);
                 return 0;
         }
@@ -244,13 +244,13 @@ int ipc_client_handle_writable(int client_fd, uint32_t mask, void *data) {
         struct ipc_client *client = data;
 
         if (mask & WL_EVENT_ERROR) {
-                sway_log(L_ERROR, "IPC Client socket error, removing client");
+                wlr_log(L_ERROR, "IPC Client socket error, removing client");
                 ipc_client_disconnect(client);
                 return 0;
         }
 
         if (mask & WL_EVENT_HANGUP) {
-                sway_log(L_DEBUG, "Client %d hung up", client->fd);
+                wlr_log(L_DEBUG, "Client %d hung up", client->fd);
                 ipc_client_disconnect(client);
                 return 0;
         }
@@ -259,14 +259,14 @@ int ipc_client_handle_writable(int client_fd, uint32_t mask, void *data) {
                 return 0;
         }
 
-        sway_log(L_DEBUG, "Client %d writable", client->fd);
+        wlr_log(L_DEBUG, "Client %d writable", client->fd);
 
         ssize_t written = write(client->fd, client->write_buffer, client->write_buffer_len);
 
         if (written == -1 && errno == EAGAIN) {
                 return 0;
         } else if (written == -1) {
-                sway_log_errno(L_INFO, "Unable to send data from queue to IPC client");
+                wlr_log_errno(L_INFO, "Unable to send data from queue to IPC client");
                 ipc_client_disconnect(client);
                 return 0;
         }
@@ -291,7 +291,7 @@ void ipc_client_disconnect(struct ipc_client *client) {
                 shutdown(client->fd, SHUT_RDWR);
         }
 
-        sway_log(L_INFO, "IPC Client %d disconnected", client->fd);
+        wlr_log(L_INFO, "IPC Client %d disconnected", client->fd);
         wl_event_source_remove(client->event_source);
         if (client->writable_event_source) {
                 wl_event_source_remove(client->writable_event_source);
@@ -313,7 +313,7 @@ void ipc_client_handle_command(struct ipc_client *client) {
 
         char *buf = malloc(client->payload_length + 1);
         if (!buf) {
-                sway_log_errno(L_INFO, "Unable to allocate IPC payload");
+                wlr_log_errno(L_INFO, "Unable to allocate IPC payload");
                 ipc_client_disconnect(client);
                 return;
         }
@@ -322,7 +322,7 @@ void ipc_client_handle_command(struct ipc_client *client) {
                 ssize_t received = recv(client->fd, buf, client->payload_length, 0);
                 if (received == -1)
                 {
-                        sway_log_errno(L_INFO, "Unable to receive payload from IPC client");
+                        wlr_log_errno(L_INFO, "Unable to receive payload from IPC client");
                         ipc_client_disconnect(client);
                         free(buf);
                         return;
@@ -393,12 +393,12 @@ void ipc_client_handle_command(struct ipc_client *client) {
         }
 
         default:
-                sway_log(L_INFO, "Unknown IPC command type %i", client->current_command);
+                wlr_log(L_INFO, "Unknown IPC command type %i", client->current_command);
                 goto exit_cleanup;
         }
 
         ipc_send_reply(client, error_denied, (uint32_t)strlen(error_denied));
-        sway_log(L_DEBUG, "Denied IPC client access to %i", client->current_command);
+        wlr_log(L_DEBUG, "Denied IPC client access to %i", client->current_command);
 
 exit_cleanup:
         client->payload_length = 0;
@@ -422,14 +422,14 @@ bool ipc_send_reply(struct ipc_client *client, const char *payload, uint32_t pay
         }
 
         if (client->write_buffer_size > 4e6) { // 4 MB
-                sway_log(L_ERROR, "Client write buffer too big, disconnecting client");
+                wlr_log(L_ERROR, "Client write buffer too big, disconnecting client");
                 ipc_client_disconnect(client);
                 return false;
         }
 
         char *new_buffer = realloc(client->write_buffer, client->write_buffer_size);
         if (!new_buffer) {
-                sway_log(L_ERROR, "Unable to reallocate ipc client write buffer");
+                wlr_log(L_ERROR, "Unable to reallocate ipc client write buffer");
                 ipc_client_disconnect(client);
                 return false;
         }
@@ -446,6 +446,6 @@ bool ipc_send_reply(struct ipc_client *client, const char *payload, uint32_t pay
                                 ipc_client_handle_writable, client);
         }
 
-        sway_log(L_DEBUG, "Added IPC reply to client %d queue: %s", client->fd, payload);
+        wlr_log(L_DEBUG, "Added IPC reply to client %d queue: %s", client->fd, payload);
         return true;
 }