libgnunetchat

library for GNUnet Messenger
Log | Files | Refs | README | LICENSE

gnunet_chat_message.c (3737B)

      1 /*
      2    This file is part of GNUnet.
      3    Copyright (C) 2021--2026 GNUnet e.V.
      4 
      5    GNUnet is free software: you can redistribute it and/or modify it
      6    under the terms of the GNU Affero General Public License as published
      7    by the Free Software Foundation, either version 3 of the License,
      8    or (at your option) any later version.
      9 
     10    GNUnet is distributed in the hope that it will be useful, but
     11    WITHOUT ANY WARRANTY; without even the implied warranty of
     12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     13    Affero General Public License for more details.
     14 
     15    You should have received a copy of the GNU Affero General Public License
     16    along with this program.  If not, see <http://www.gnu.org/licenses/>.
     17 
     18    SPDX-License-Identifier: AGPL3.0-or-later
     19  */
     20 /*
     21  * @author Tobias Frisch
     22  * @file gnunet_chat_message.c
     23  */
     24 
     25 #include "gnunet_chat_message.h"
     26 #include "gnunet_chat_context.h"
     27 
     28 #include <gnunet/gnunet_messenger_service.h>
     29 
     30 struct GNUNET_CHAT_Message*
     31 message_create_from_msg (struct GNUNET_CHAT_Context *context,
     32                          const struct GNUNET_HashCode *hash,
     33                          enum GNUNET_MESSENGER_MessageFlags flags,
     34                          const struct GNUNET_MESSENGER_Message *msg)
     35 {
     36   GNUNET_assert((context) && (hash) && (msg));
     37 
     38   struct GNUNET_CHAT_Message *message = GNUNET_new(struct GNUNET_CHAT_Message);
     39 
     40   message->account = NULL;
     41   message->context = context;
     42   message->task = NULL;
     43 
     44   GNUNET_memcpy(&(message->hash), hash, sizeof(message->hash));
     45   message->flags = flags;
     46   message->flag = GNUNET_CHAT_FLAG_NONE;
     47 
     48   message->warning_buffer = NULL;
     49 
     50   message->msg = msg;
     51   message->user_pointer = NULL;
     52 
     53   return message;
     54 }
     55 
     56 struct GNUNET_CHAT_Message*
     57 message_create_internally (struct GNUNET_CHAT_Account *account,
     58                            struct GNUNET_CHAT_Context *context,
     59                            enum GNUNET_CHAT_MessageFlag flag,
     60                            const char *warning,
     61                            enum GNUNET_GenericReturnValue async_warning)
     62 {
     63   struct GNUNET_CHAT_Message *message = GNUNET_new(struct GNUNET_CHAT_Message);
     64 
     65   message->account = account;
     66   message->context = context;
     67   message->task = NULL;
     68 
     69   memset(&(message->hash), 0, sizeof(message->hash));
     70   message->flags = GNUNET_MESSENGER_FLAG_PRIVATE;
     71   message->flag = flag;
     72 
     73   if (GNUNET_YES == async_warning)
     74     message->warning_buffer = warning? GNUNET_strdup(warning) : NULL;
     75   else
     76     message->warning_buffer = NULL;
     77 
     78   message->warning = GNUNET_YES == async_warning? message->warning_buffer : warning;
     79   message->user_pointer = NULL;
     80 
     81   return message;
     82 }
     83 
     84 enum GNUNET_GenericReturnValue
     85 message_has_msg (const struct GNUNET_CHAT_Message* message)
     86 {
     87   GNUNET_assert(message);
     88 
     89   if (message->flag != GNUNET_CHAT_FLAG_NONE)
     90     return GNUNET_NO;
     91 
     92   if (message->msg)
     93     return GNUNET_YES;
     94   else
     95     return GNUNET_NO;
     96 }
     97 
     98 void
     99 message_update_msg (struct GNUNET_CHAT_Message* message,
    100                     enum GNUNET_MESSENGER_MessageFlags flags,
    101                     const struct GNUNET_MESSENGER_Message *msg)
    102 {
    103   GNUNET_assert((message) && (msg));
    104 
    105   if ((GNUNET_YES != message_has_msg(message)) ||
    106       (message->flags & GNUNET_MESSENGER_FLAG_DELETE))
    107     return;
    108 
    109   if (flags & GNUNET_MESSENGER_FLAG_UPDATE)
    110     message->msg = msg;
    111   else if (flags & GNUNET_MESSENGER_FLAG_DELETE)
    112     context_delete_message(message->context, message);
    113   else
    114     return;
    115 
    116   message->flags = flags | GNUNET_MESSENGER_FLAG_UPDATE;
    117 }
    118 
    119 void
    120 message_destroy (struct GNUNET_CHAT_Message* message)
    121 {
    122   GNUNET_assert(message);
    123 
    124   if (message->task)
    125     GNUNET_SCHEDULER_cancel(message->task);
    126 
    127   if (message->warning_buffer)
    128     GNUNET_free(message->warning_buffer);
    129 
    130   GNUNET_free(message);
    131 }