1/*-
2 * Copyright (c) 2016 Kai Wang
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27#include <sys/param.h>
28#include <assert.h>
29#include <errno.h>
30#include <stdlib.h>
31#include <unistd.h>
32
33#include "_libpe.h"
34
35ELFTC_VCSID("$Id: libpe_buffer.c 3312 2016-01-10 09:23:51Z kaiwang27 $");
36
37PE_SecBuf *
38libpe_alloc_buffer(PE_Scn *ps, size_t sz)
39{
40	PE_SecBuf *sb;
41
42	if ((sb = malloc(sizeof(PE_SecBuf))) == NULL) {
43		errno = ENOMEM;
44		return (NULL);
45	}
46
47	sb->sb_ps = ps;
48	sb->sb_flags = 0;
49	sb->sb_pb.pb_align = 1;
50	sb->sb_pb.pb_off = 0;
51	sb->sb_pb.pb_size = sz;
52	if (sz > 0) {
53		if ((sb->sb_pb.pb_buf = malloc(sz)) == NULL) {
54			free(sb);
55			errno = ENOMEM;
56			return (NULL);
57		}
58		sb->sb_flags |= LIBPE_F_BUFFER_MALLOCED;
59	} else
60		sb->sb_pb.pb_buf = NULL;
61
62	STAILQ_INSERT_TAIL(&ps->ps_b, sb, sb_next);
63
64	return (sb);
65}
66
67void
68libpe_release_buffer(PE_SecBuf *sb)
69{
70	PE_Scn *ps;
71
72	assert(sb != NULL);
73
74	ps = sb->sb_ps;
75
76	STAILQ_REMOVE(&ps->ps_b, sb, _PE_SecBuf, sb_next);
77
78	if (sb->sb_flags & LIBPE_F_BUFFER_MALLOCED)
79		free(sb->sb_pb.pb_buf);
80
81	free(sb);
82}
83
84static int
85cmp_sb(PE_SecBuf *a, PE_SecBuf *b)
86{
87
88	if (a->sb_pb.pb_off < b->sb_pb.pb_off)
89		return (-1);
90	else if (a->sb_pb.pb_off == b->sb_pb.pb_off)
91		return (0);
92	else
93		return (1);
94}
95
96static void
97sort_buffers(PE_Scn *ps)
98{
99
100	if (STAILQ_EMPTY(&ps->ps_b))
101		return;
102
103	STAILQ_SORT(&ps->ps_b, _PE_SecBuf, sb_next, cmp_sb);
104}
105
106size_t
107libpe_resync_buffers(PE_Scn *ps)
108{
109	PE_SecBuf *sb;
110	PE_Buffer *pb;
111	size_t sz;
112
113	assert(ps->ps_flags & LIBPE_F_LOAD_SECTION);
114
115	sort_buffers(ps);
116
117	sz = 0;
118	STAILQ_FOREACH(sb, &ps->ps_b, sb_next) {
119		if (ps->ps_flags & PE_F_DIRTY)
120			sb->sb_flags |= PE_F_DIRTY;
121
122		pb = (PE_Buffer *) sb;
123		if (pb->pb_align > ps->ps_falign)
124			pb->pb_align = ps->ps_falign;
125		if (pb->pb_buf == NULL || pb->pb_size == 0)
126			continue;
127
128		sz = roundup(sz, pb->pb_align);
129
130		if (pb->pb_off != (off_t) sz) {
131			pb->pb_off = sz;
132			sb->sb_flags |= PE_F_DIRTY;
133		}
134		sz += pb->pb_size;
135	}
136
137	return (sz);
138}
139
140int
141libpe_write_buffers(PE_Scn *ps)
142{
143	PE *pe;
144	PE_SecBuf *sb;
145	PE_Buffer *pb;
146	off_t off;
147
148	assert(ps->ps_flags & LIBPE_F_LOAD_SECTION);
149
150	pe = ps->ps_pe;
151
152	off = 0;
153	STAILQ_FOREACH(sb, &ps->ps_b, sb_next) {
154		pb = &sb->sb_pb;
155		if (pb->pb_buf == NULL || pb->pb_size == 0)
156			continue;
157
158		if ((sb->sb_flags & PE_F_DIRTY) == 0) {
159			assert((pe->pe_flags & LIBPE_F_SPECIAL_FILE) == 0);
160			if (lseek(pe->pe_fd, (off_t) pb->pb_size, SEEK_CUR) <
161			    0) {
162				errno = EIO;
163				return (-1);
164			}
165			goto next_buf;
166		}
167
168		if (pb->pb_off > off) {
169			if (libpe_pad(pe, pb->pb_off - off) < 0)
170				return (-1);
171			off = pb->pb_off;
172		}
173
174		if (write(pe->pe_fd, pb->pb_buf, pb->pb_size) !=
175		    (ssize_t) pb->pb_size) {
176			errno = EIO;
177			return (-1);
178		}
179
180	next_buf:
181		off += pb->pb_size;
182	}
183
184	return (0);
185}
186