Return to ssvn_lock.c CVS log

Up to [Coherent Logic Development] / freem / src

Second phase of REUSE compliance and header reformat

    1: /*
    2:  *   $Id: ssvn_lock.c,v 1.4 2025/03/09 19:50:47 snw Exp $
    3:  *    ^$LOCK ssvn
    4:  *
    5:  *  
    6:  *   Author: Serena Willis <snw@coherent-logic.com>
    7:  *    Copyright (C) 1998 MUG Deutschland
    8:  *    Copyright (C) 2020, 2025 Coherent Logic Development LLC
    9:  *
   10:  *
   11:  *   This file is part of FreeM.
   12:  *
   13:  *   FreeM is free software: you can redistribute it and/or modify
   14:  *   it under the terms of the GNU Affero Public License as published by
   15:  *   the Free Software Foundation, either version 3 of the License, or
   16:  *   (at your option) any later version.
   17:  *
   18:  *   FreeM is distributed in the hope that it will be useful,
   19:  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   20:  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   21:  *   GNU Affero Public License for more details.
   22:  *
   23:  *   You should have received a copy of the GNU Affero Public License
   24:  *   along with FreeM.  If not, see <https://www.gnu.org/licenses/>.
   25:  *
   26:  *   $Log: ssvn_lock.c,v $
   27:  *   Revision 1.4  2025/03/09 19:50:47  snw
   28:  *   Second phase of REUSE compliance and header reformat
   29:  *
   30:  *
   31:  * SPDX-FileCopyrightText:  (C) 2025 Coherent Logic Development LLC
   32:  * SPDX-License-Identifier: AGPL-3.0-or-later
   33:  **/
   34: 
   35: #include <stdio.h>
   36: #include <stdlib.h>
   37: #include <string.h>
   38: 
   39: #include "mpsdef.h"
   40: #include "mref.h"
   41: 
   42: void ssvn_lock_add(char *key, pid_t owner_job, int count)
   43: {
   44:     register int i;
   45: 
   46:     char *t_buf;
   47:     char *k_buf;
   48:     char *d_buf;
   49:     freem_ref_t *r;
   50:     
   51:     t_buf = (char *) malloc (STRLEN * sizeof (char));
   52:     NULLPTRCHK(t_buf,"ssvn_lock_add");
   53:     
   54:     k_buf = (char *) malloc (STRLEN * sizeof (char));
   55:     NULLPTRCHK(k_buf,"ssvn_lock_add");
   56: 
   57:     d_buf = (char *) malloc (STRLEN * sizeof (char));
   58:     NULLPTRCHK(d_buf,"ssvn_lock_add");
   59:     
   60:     r = (freem_ref_t *) malloc (sizeof (freem_ref_t));
   61:     NULLPTRCHK(r,"ssvn_lock_add");
   62: 
   63:     mref_init (r, MREF_RT_GLOBAL, "");
   64:     internal_to_mref (r, key);
   65:     mref_to_external (r, t_buf);
   66: 
   67:     //printf ("key = '%s'\r\n", key);
   68:     //printf ("r = '%s'\r\n", t_buf);
   69:     
   70:     for (i = 0; i < strlen (t_buf); i++) {
   71: 
   72:         if (t_buf[i] == '\001') {
   73:             t_buf[i] = '\0';
   74:             break;
   75:         }
   76: 
   77:     }
   78:     
   79:     snprintf (k_buf, STRLEN - 1, "^$LOCK\202%s\201", t_buf);
   80:     snprintf (d_buf, STRLEN - 1, "%ld,%d\201\0", (long) owner_job, count);
   81: 
   82:     symtab_shm (set_sym, k_buf, d_buf);
   83: 
   84:     free (t_buf);
   85:     free (k_buf);
   86:     free (d_buf);
   87:     free (r);
   88:     
   89: }
   90: 
   91: void ssvn_lock_remove(char *key)
   92: {
   93:     register int i;
   94: 
   95:     char *t_buf;
   96:     char *k_buf;
   97:     char *d_buf;
   98:     freem_ref_t *r;
   99:     
  100:     t_buf = (char *) malloc (STRLEN * sizeof (freem_ref_t));
  101:     NULLPTRCHK(t_buf,"ssvn_lock_add");
  102:     
  103:     k_buf = (char *) malloc (STRLEN * sizeof (freem_ref_t));
  104:     NULLPTRCHK(k_buf,"ssvn_lock_add");
  105: 
  106:     d_buf = (char *) malloc (STRLEN * sizeof (freem_ref_t));
  107:     NULLPTRCHK(d_buf,"ssvn_lock_add");
  108:     
  109:     r = (freem_ref_t *) malloc (sizeof (freem_ref_t));
  110:     NULLPTRCHK(r,"ssvn_lock_add");
  111: 
  112:     mref_init (r, MREF_RT_GLOBAL, "");
  113:     internal_to_mref (r, key);
  114:     mref_to_external (r, t_buf);
  115: 
  116:     for (i = 0; i < strlen (t_buf); i++) {
  117: 
  118:         if (t_buf[i] == '\001') {
  119:             t_buf[i] = '\0';
  120:             break;
  121:         }
  122: 
  123:     }
  124:     
  125:     snprintf (k_buf, STRLEN - 1, "^$LOCK\202%s\201", t_buf);
  126:     snprintf (d_buf, STRLEN - 1, " \201");
  127: 
  128:     symtab_shm (kill_sym, k_buf, d_buf);
  129:     
  130: }
  131: 
  132: void ssvn_lock(short action, char *key, char *data)
  133: {
  134: 
  135:     switch (action) {
  136: 
  137:         case set_sym:       
  138:         case kill_sym:
  139:             //TODO: remove lock            
  140:             merr_raise (M29);
  141:             return;
  142:             
  143:         default:
  144:             symtab_shm (action, key, data);
  145:             break;
  146: 
  147:     }
  148:     
  149:     return;
  150: }