14682

pending completion

Build # 14682

Build Type

push

travis-ci

Committed by

locker

Commit Message

lua: getpwall/getgrall error handling - follow-up fixes

 - Add the forgotten errno(0) to getgrall.
 - Throw errors from getgrall/getpwall instead of returning nil in
   case the underlying system function fails.
 - Fix the error message in getgr.
 - Remove pointless and confusing asterisk sign from error messages.
 - Do not hide a stack frame on error.

Follow-up efccac691a46 ("lua: fix error handling in getpwall and
getgrall").

(cherry picked from commit a1606e913)

Run Details

40988 of 49902 relevant lines covered (82.14%)

853752.04 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.77

/src/box/error.h

#ifndef TARANTOOL_BOX_ERROR_H_INCLUDED
#define TARANTOOL_BOX_ERROR_H_INCLUDED
/*
 * Copyright 2010-2016, Tarantool AUTHORS, please see AUTHORS file.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *
 * 1. Redistributions of source code must retain the above
 *    copyright notice, this list of conditions and the
 *    following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
#include "errcode.h"

#if defined(__cplusplus)
extern "C" {
#endif /* defined(__cplusplus) */

struct vclock;

struct error *
BuildClientError(const char *file, unsigned line, uint32_t errcode, ...);

struct error *
BuildAccessDeniedError(const char *file, unsigned int line,
                       const char *access_type, const char *object_type,
                       const char *object_name, const char *user_name);

struct error *
BuildXlogError(const char *file, unsigned line, const char *format, ...);

struct error *
BuildXlogGapError(const char *file, unsigned line,
                  const struct vclock *from, const struct vclock *to);

/** \cond public */

struct error;
/**
 * Error - contains information about error.
 */
typedef struct error box_error_t;

/**
 * Return the error type, e.g. "ClientError", "SocketError", etc.
 * \param error
 * \return not-null string
 */
const char *
box_error_type(const box_error_t *error);

/**
 * Return IPROTO error code
 * \param error error
 * \return enum box_error_code
 */
uint32_t
box_error_code(const box_error_t *error);

/**
 * Return the error message
 * \param error error
 * \return not-null string
 */
const char *
box_error_message(const box_error_t *error);

/**
 * Get the information about the last API call error.
 *
 * The Tarantool error handling works most like libc's errno. All API calls
 * return -1 or NULL in the event of error. An internal pointer to
 * box_error_t type is set by API functions to indicate what went wrong.
 * This value is only significant if API call failed (returned -1 or NULL).
 *
 * Successful function can also touch the last error in some
 * cases. You don't have to clear the last error before calling
 * API functions. The returned object is valid only until next
 * call to **any** API function.
 *
 * You must set the last error using box_error_set() in your stored C
 * procedures if you want to return a custom error message.
 * You can re-throw the last API error to IPROTO client by keeping
 * the current value and returning -1 to Tarantool from your
 * stored procedure.
 *
 * \return last error.
 */
box_error_t *
box_error_last(void);

/**
 * Clear the last error.
 */
void
box_error_clear(void);

/**
 * Set the last error.
 *
 * \param code IPROTO error code (enum \link box_error_code \endlink)
 * \param format (const char * ) - printf()-like format string
 * \param ... - format arguments
 * \returns -1 for convention use
 *
 * \sa enum box_error_code
 */
int
box_error_set(const char *file, unsigned line, uint32_t code,
              const char *format, ...);

/**
 * A backward-compatible API define.
 */
#define box_error_raise(code, format, ...) \
        box_error_set(__FILE__, __LINE__, code, format, ##__VA_ARGS__)

/** \endcond public */

extern const struct type_info type_ClientError;
extern const struct type_info type_XlogError;
extern const struct type_info type_AccessDeniedError;

#if defined(__cplusplus)
} /* extern "C" */
#include "exception.h"

struct rmean;
extern "C" struct rmean *rmean_error;

enum rmean_error_name {
        RMEAN_ERROR,
        RMEAN_ERROR_LAST
};
extern const char *rmean_error_strings[RMEAN_ERROR_LAST];

class ClientError: public Exception
{
public:
        virtual void raise()
        {
                throw this;
        }

        virtual void log() const;

        int
        errcode() const
        {
                return m_errcode;
        }

        ClientError(const char *file, unsigned line, uint32_t errcode, ...);

        static uint32_t get_errcode(const struct error *e);
        /* client errno code */
        int m_errcode;
protected:
        ClientError(const type_info *type, const char *file, unsigned line,
                    uint32_t errcode);
};

class LoggedError: public ClientError
{
public:
        template <typename ... Args>
        LoggedError(const char *file, unsigned line, uint32_t errcode, Args ... args)
                : ClientError(file, line, errcode, args...)
        {
                /* TODO: actually calls ClientError::log */
                log();
        }
};

/**
 * A special type of exception which must be used
 * for all access denied errors, since it invokes audit triggers.
 */
class AccessDeniedError: public ClientError
{
public:
        AccessDeniedError(const char *file, unsigned int line,
                          const char *access_type, const char *object_type,
                          const char *object_name, const char *user_name);

        ~AccessDeniedError()
        {
                free(m_object_name);
        }

        const char *
        object_type()
        {
                return m_object_type;
        }

        const char *
        object_name()
        {
                return m_object_name?:"(nil)";
        }

        const char *
        access_type()
        {
                return m_access_type;
        }

private:
        /** Type of object the required access was denied to */
        const char *m_object_type;
        /** Name of object the required access was denied to */
        char *m_object_name;
        /** Type of declined access */
        const char *m_access_type;
};

/**
 * XlogError is raised when there is an error with contents
 * of the data directory or a log file. A special subclass
 * of exception is introduced to gracefully skip such errors
 * in force_recovery = true mode.
 */
struct XlogError: public Exception
{
        XlogError(const char *file, unsigned line, const char *format,
                  va_list ap)
                :Exception(&type_XlogError, file, line)
        {
                error_vformat_msg(this, format, ap);
        }
        XlogError(const struct type_info *type, const char *file,
                  unsigned line)
                :Exception(type, file, line)
        {
        }

        virtual void raise() { throw this; }
};

struct XlogGapError: public XlogError
{
        XlogGapError(const char *file, unsigned line,
                     const struct vclock *from, const struct vclock *to);

        virtual void raise() { throw this; }
};

#endif /* defined(__cplusplus) */

#endif /* TARANTOOL_BOX_ERROR_H_INCLUDED */

1	#ifndef TARANTOOL_BOX_ERROR_H_INCLUDED
2	#define TARANTOOL_BOX_ERROR_H_INCLUDED
3	/*
4	* Copyright 2010-2016, Tarantool AUTHORS, please see AUTHORS file.
5	*
6	* Redistribution and use in source and binary forms, with or
7	* without modification, are permitted provided that the following
8	* conditions are met:
9	*
10	* 1. Redistributions of source code must retain the above
11	* copyright notice, this list of conditions and the
12	* following disclaimer.
13	*
14	* 2. Redistributions in binary form must reproduce the above
15	* copyright notice, this list of conditions and the following
16	* disclaimer in the documentation and/or other materials
17	* provided with the distribution.
18	*
19	* THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
20	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
23	* <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
24	* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
30	* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31	* SUCH DAMAGE.
32	*/
33	#include "errcode.h"
34
35	#if defined(__cplusplus)
36	extern "C" {
37	#endif /* defined(__cplusplus) */
38
39	struct vclock;
40
41	struct error *
42	BuildClientError(const char *file, unsigned line, uint32_t errcode, ...);
43
44	struct error *
45	BuildAccessDeniedError(const char *file, unsigned int line,
46	const char access_type, const char object_type,
47	const char object_name, const char user_name);
48
49	struct error *
50	BuildXlogError(const char file, unsigned line, const char format, ...);
51
52	struct error *
53	BuildXlogGapError(const char *file, unsigned line,
54	const struct vclock from, const struct vclock to);
55
56	/** \cond public */
57
58	struct error;
59	/**
60	* Error - contains information about error.
61	*/
62	typedef struct error box_error_t;
63
64	/**
65	* Return the error type, e.g. "ClientError", "SocketError", etc.
66	* \param error
67	* \return not-null string
68	*/
69	const char *
70	box_error_type(const box_error_t *error);
71
72	/**
73	* Return IPROTO error code
74	* \param error error
75	* \return enum box_error_code
76	*/
77	uint32_t
78	box_error_code(const box_error_t *error);
79
80	/**
81	* Return the error message
82	* \param error error
83	* \return not-null string
84	*/
85	const char *
86	box_error_message(const box_error_t *error);
87
88	/**
89	* Get the information about the last API call error.
90	*
91	* The Tarantool error handling works most like libc's errno. All API calls
92	* return -1 or NULL in the event of error. An internal pointer to
93	* box_error_t type is set by API functions to indicate what went wrong.
94	* This value is only significant if API call failed (returned -1 or NULL).
95	*
96	* Successful function can also touch the last error in some
97	* cases. You don't have to clear the last error before calling
98	* API functions. The returned object is valid only until next
99	* call to any API function.
100	*
101	* You must set the last error using box_error_set() in your stored C
102	* procedures if you want to return a custom error message.
103	* You can re-throw the last API error to IPROTO client by keeping
104	* the current value and returning -1 to Tarantool from your
105	* stored procedure.
106	*
107	* \return last error.
108	*/
109	box_error_t *
110	box_error_last(void);
111
112	/**
113	* Clear the last error.
114	*/
115	void
116	box_error_clear(void);
117
118	/**
119	* Set the last error.
120	*
121	* \param code IPROTO error code (enum \link box_error_code \endlink)
122	* \param format (const char * ) - printf()-like format string
123	* \param ... - format arguments
124	* \returns -1 for convention use
125	*
126	* \sa enum box_error_code
127	*/
128	int
129	box_error_set(const char *file, unsigned line, uint32_t code,
130	const char *format, ...);
131
132	/**
133	* A backward-compatible API define.
134	*/
135	#define box_error_raise(code, format, ...) \
136	box_error_set(__FILE__, __LINE__, code, format, ##__VA_ARGS__)
137
138	/** \endcond public */
139
140	extern const struct type_info type_ClientError;
141	extern const struct type_info type_XlogError;
142	extern const struct type_info type_AccessDeniedError;
143
144	#if defined(__cplusplus)
145	} /* extern "C" */
146	#include "exception.h"
147
148	struct rmean;
149	extern "C" struct rmean *rmean_error;
150
151	enum rmean_error_name {
152	RMEAN_ERROR,
153	RMEAN_ERROR_LAST
154	};
155	extern const char *rmean_error_strings[RMEAN_ERROR_LAST];
156
157	class ClientError: public Exception	75,801✔
158	{
159	public:
160	virtual void raise()	882✔
161	{
162	throw this;	882✔
163	}
164
165	virtual void log() const;
166
167	int
168	errcode() const	4,350✔
169	{
170	return m_errcode;	4,350✔
171	}
172
173	ClientError(const char *file, unsigned line, uint32_t errcode, ...);
174
175	static uint32_t get_errcode(const struct error *e);
176	/* client errno code */
177	int m_errcode;
178	protected:
179	ClientError(const type_info type, const char file, unsigned line,
180	uint32_t errcode);
181	};
182
183	class LoggedError: public ClientError	×
184	{
185	public:
186	template <typename ... Args>
187	LoggedError(const char *file, unsigned line, uint32_t errcode, Args ... args)	3✔
188	: ClientError(file, line, errcode, args...)	3✔
189	{
190	/* TODO: actually calls ClientError::log */
191	log();	3✔
192	}	3✔
193	};
194
195	/**
196	* A special type of exception which must be used
197	* for all access denied errors, since it invokes audit triggers.
198	*/
199	class AccessDeniedError: public ClientError
200	{
201	public:
202	AccessDeniedError(const char *file, unsigned int line,
203	const char access_type, const char object_type,
204	const char object_name, const char user_name);
205
206	~AccessDeniedError()	216✔
207	{	216✔
208	free(m_object_name);	108✔
209	}	216✔
210
211	const char *
212	object_type()	1✔
213	{
214	return m_object_type;	1✔
215	}
216
217	const char *
218	object_name()	1✔
219	{
220	return m_object_name?:"(nil)";	1✔
221	}
222
223	const char *
224	access_type()	1✔
225	{
226	return m_access_type;	1✔
227	}
228
229	private:
230	/** Type of object the required access was denied to */
231	const char *m_object_type;
232	/** Name of object the required access was denied to */
233	char *m_object_name;
234	/** Type of declined access */
235	const char *m_access_type;
236	};
237
238	/**
239	* XlogError is raised when there is an error with contents
240	* of the data directory or a log file. A special subclass
241	* of exception is introduced to gracefully skip such errors
242	* in force_recovery = true mode.
243	*/
244	struct XlogError: public Exception	57✔
245	{
246	XlogError(const char file, unsigned line, const char format,	27✔
247	va_list ap)
248	:Exception(&type_XlogError, file, line)	27✔
249	{
250	error_vformat_msg(this, format, ap);	27✔
251	}	27✔
252	XlogError(const struct type_info type, const char file,	16✔
253	unsigned line)
254	:Exception(type, file, line)	16✔
255	{
256	}	16✔
257
258	virtual void raise() { throw this; }	2✔
259	};
260
261	struct XlogGapError: public XlogError	26✔
262	{
263	XlogGapError(const char *file, unsigned line,
264	const struct vclock from, const struct vclock to);
265
266	virtual void raise() { throw this; }	5✔
267	};
268
269	#endif /* defined(__cplusplus) */
270
271	#endif /* TARANTOOL_BOX_ERROR_H_INCLUDED */

tarantool / tarantool / 14682

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous