Annotation of ansh/src/proc.c, revision 1.4

1.1       misho       1: /*************************************************************************
                      2:  * (C) 2011 AITNET - Sofia/Bulgaria - <office@aitnet.org>
                      3:  *  by Michael Pounov <misho@elwix.org>
                      4:  *
                      5:  * $Author: misho $
1.4     ! misho       6:  * $Id: proc.c,v 1.3.2.2 2012/05/23 15:41:38 misho Exp $
1.1       misho       7:  *
1.2       misho       8:  *************************************************************************
                      9: The ELWIX and AITNET software is distributed under the following
                     10: terms:
                     11: 
                     12: All of the documentation and software included in the ELWIX and AITNET
                     13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
                     14: 
1.4     ! misho      15: Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
1.2       misho      16:        by Michael Pounov <misho@elwix.org>.  All rights reserved.
                     17: 
                     18: Redistribution and use in source and binary forms, with or without
                     19: modification, are permitted provided that the following conditions
                     20: are met:
                     21: 1. Redistributions of source code must retain the above copyright
                     22:    notice, this list of conditions and the following disclaimer.
                     23: 2. Redistributions in binary form must reproduce the above copyright
                     24:    notice, this list of conditions and the following disclaimer in the
                     25:    documentation and/or other materials provided with the distribution.
                     26: 3. All advertising materials mentioning features or use of this software
                     27:    must display the following acknowledgement:
                     28: This product includes software developed by Michael Pounov <misho@elwix.org>
                     29: ELWIX - Embedded LightWeight unIX and its contributors.
                     30: 4. Neither the name of AITNET nor the names of its contributors
                     31:    may be used to endorse or promote products derived from this software
                     32:    without specific prior written permission.
                     33: 
                     34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
                     35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     37: ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     44: SUCH DAMAGE.
                     45: */
1.1       misho      46: #include "global.h"
                     47: #include "anshd.h"
                     48: #include "proc.h"
                     49: 
                     50: 
                     51: struct tagProc *
1.3       misho      52: InitProc(int h, io_sockaddr_t *sa, u_short id, int len)
1.1       misho      53: {
                     54:        struct tagProc *proc;
                     55: 
                     56:        FTRACE(5);
                     57: 
1.4     ! misho      58:        proc = io_malloc(sizeof(struct tagProc));
1.1       misho      59:        if (!proc) {
                     60:                ERR("Not enough memory #%d - %s", errno, strerror(errno));
                     61:                return NULL;
                     62:        } else
                     63:                memset(proc, 0, sizeof(struct tagProc));
                     64:        proc->proc_sock = h;
                     65:        proc->proc_id = id;
                     66:        if (sa)
1.3       misho      67:                memcpy(&proc->proc_cli, sa, sizeof(io_sockaddr_t));
1.1       misho      68: 
                     69:        proc->proc_blen = len;
1.4     ! misho      70:        proc->proc_buf_[0] = io_malloc(proc->proc_blen);
1.1       misho      71:        if (!proc->proc_buf_[0]) {
1.4     ! misho      72:                io_free(proc);
1.1       misho      73:                proc = NULL;
                     74:        }
1.4     ! misho      75:        proc->proc_buf_[1] = io_malloc(proc->proc_blen);
1.1       misho      76:        if (!proc->proc_buf_[1]) {
1.4     ! misho      77:                io_free(proc->proc_buf_[0]);
        !            78:                io_free(proc);
1.1       misho      79:                proc = NULL;
                     80:        }
                     81: 
                     82:        SLIST_INSERT_HEAD(&pH, proc, proc_next);
                     83:        return proc;
                     84: }
                     85: 
                     86: void
                     87: FiniProcByID(u_short id)
                     88: {
                     89:        struct tagProc *proc;
                     90: 
                     91:        SLIST_FOREACH(proc, &pH, proc_next)
                     92:                if (proc->proc_id == id) {
                     93:                        SLIST_REMOVE(&pH, proc, tagProc, proc_next);
                     94:                        FreeProc(&proc);
                     95:                }
                     96: }
                     97: 
                     98: void
                     99: FreeProc(struct tagProc ** __restrict proc)
                    100: {
                    101:        FTRACE(5);
                    102: 
                    103:        assert(proc && *proc);
                    104:        if (!*proc)
                    105:                return;
                    106: 
                    107:        if ((*proc)->proc_buf_[1])
1.4     ! misho     108:                io_free((*proc)->proc_buf_[1]);
1.1       misho     109:        if ((*proc)->proc_buf_[0])
1.4     ! misho     110:                io_free((*proc)->proc_buf_[0]);
        !           111:        io_free(*proc);
1.1       misho     112:        *proc = NULL;
                    113: }
                    114: 
                    115: void
                    116: DestroyProc()
                    117: {
                    118:        struct tagProc *proc;
                    119: 
                    120:        while ((proc = SLIST_FIRST(&pH))) {
                    121:                SLIST_REMOVE_HEAD(&pH, proc_next);
                    122:                FreeProc(&proc);
                    123:        }
                    124: }
1.4     ! misho     125: 
        !           126: 
        !           127: int
        !           128: stopProcess(sched_root_task_t * __restrict root, proc_head_t * __restrict h, pid_t pid, sched_task_func_t func)
        !           129: {
        !           130:        struct tagProc *p;
        !           131: 
        !           132:        FTRACE(3);
        !           133: 
        !           134:        SLIST_FOREACH(p, h, proc_next)
        !           135:                if (p->proc_pid == pid) {
        !           136:                        break;
        !           137:                }
        !           138:        VERB(3) LOG("pid=%d found=%p\n", pid, p);
        !           139:        if (!p)
        !           140:                return 1;
        !           141: 
        !           142:        ioFreePTY(p->proc_pty, p->proc_ttyname);
        !           143:        if (p->proc_pty)
        !           144:                schedCancelby(root, taskMAX, CRITERIA_FD, (void*) ((intptr_t) p->proc_pty), NULL);
        !           145: 
        !           146:        p->proc_pty = 0;
        !           147:        p->proc_pid = 0;
        !           148:        p->proc_seq = 0;
        !           149:        p->proc_flg = ANSH_FLG_EOF;
        !           150:        p->proc_rlen_[FD2NET] = 0;
        !           151: 
        !           152:        schedCallOnce(root, func, p, p->proc_sock, NULL, 0);
        !           153:        return 0;
        !           154: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>