Robin Hourahane / Improved-mbed-rpc

Improved RPC library with added bounds checking to stop memory corruption, removed memory leaks, Arduino pin names, better object discovery.

Fork of mbed-rpc by mbed official

I have added bounds checking in both Argument and Reply classes to stop existing buffer over-runs in both classes.

Added the ability to discover the name and class of an RPC object to allow better discovery of existing objects on a server. Removed a memory leak with externally created RPC objects. Ensured consistency so that externally created objects can't be deleted using the RPC interface and are correctly listed after RPC::clear.

Updated RPCVariable to use references instead of pointers to ensure that the compiler checks that there is always a valid backing variable. Also removed RPC new/delete functionality as this is not valid. Added a specialisation of RPCVariable to allow for strings to be read and written via RPC.

Added Arduino pin names to parse_pins, currently only for FRDM boards but same code should work for others just need to add them to the #ifdef.

RPCVariable.h

Committer:
rhourahane
Date:
2015-03-30
Revision:
10:7511acfaa62d
Parent:
1:6919289a5946

File content as of revision 10:7511acfaa62d:

/* mbed Microcontroller Library
 * Copyright (c) 2006-2013 ARM Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef RPCVARIABLE_H_
#define RPCVARIABLE_H_

#include "rpc.h"

namespace mbed {

/**
 *Class to read and set an attached variable using the RPC
 *
 */
template<class T>
class RPCVariable: public RPC {
public:
    /**
     * Constructor
     *
     *@param var Reference to variable to be exposed through RPC.
     *@param name The name of that this object will be over RPC
     */
    RPCVariable(T &var, const char * name = NULL) : RPC(name), _var(var) {
    }
    
    /**
     *Read the variable over RPC.
     *
     *@return The value of the variable
     */
    T read() {
        return (_var);
    }
    /**
     *Write a value to the variable over RPC
     *
     *@param The value to be written to the attached variable.
     */
    void write(T value) {
        _var = value;
    }

    virtual const struct rpc_method *get_rpc_methods();

private:
    T &_var;
};

template<class T>
const rpc_method *RPCVariable<T>::get_rpc_methods() {
    static const rpc_method rpc_methods[] = {
        {"read" , rpc_method_caller<T, RPCVariable, &RPCVariable::read> },
        {"write", rpc_method_caller<RPCVariable, T, &RPCVariable::write> },
        RPC_METHOD_END
    };
    return rpc_methods;
}

/// Specialisation of the RPCVariable class to handle strings.
/// The class is passed a pointer to the buffer and its size
/// to avoid buffer overruns.
template<>
class RPCVariable<char *>: public RPC {
public:
    /**
     * Constructor
     *
     *@param var Pointer to the char buffer used to hold the string being exposed by RPC.
     *@param bufSize Size of the buffer in chars.
     *@param name The name of that this object will be over RPC
     */
    RPCVariable(char *var, int bufSize, const char * name = NULL) : RPC(name), _var(var), _size(bufSize - 1) {
    }
    
    /**
     *Read the variable over RPC.
     *
     *@return The value of the buffer
     */
    char * read() {
        return (_var);
    }
    /**
     *Write a value to the variable over RPC
     *
     *@param The value to be written to the buffer.
     */
    void write(char *value) {
        strncpy(_var, value, _size);
        _var[_size] = 0;
    }


    virtual const rpc_method *get_rpc_methods() {
        static const rpc_method rpc_methods[] = {
            {"read" , rpc_method_caller<char *, RPCVariable, &RPCVariable::read> },
            {"write", rpc_method_caller<RPCVariable, char *, &RPCVariable::write> },
            RPC_METHOD_END
        };
        return rpc_methods;
    }

private:
    char *_var;
    
    // Holds the number of chars excluding the terminating null.
    int _size;
};
}

#endif  //RPCVARIABLE_H_