int send_fcgi_buffer(t_fcgi_buffer *fcgi_buffer, const char *buffer, int size) {
/* int padding;*/
if (size > FCGI_BUFFER_SIZE) {
if (fcgi_buffer->size > 0) {
set_padding(fcgi_buffer, true);
if (send_directly(fcgi_buffer->sock, (char*)fcgi_buffer->data, fcgi_buffer->size) == -1) {
return -1;
}
}
memcpy(fcgi_buffer->data, "\x01\x00\x00\x01" "\xff\xff\x00\x00", 8);
fcgi_buffer->data[1] = fcgi_buffer->mode;
fcgi_buffer->data[4] = (FCGI_BUFFER_SIZE >> 8 ) & 255;
fcgi_buffer->data[5] = FCGI_BUFFER_SIZE & 255;
int padding = set_padding(fcgi_buffer, false);
if (send_directly(fcgi_buffer->sock, (char*)fcgi_buffer->data, 8) == -1) {
return -1;
} else if (send_directly(fcgi_buffer->sock, buffer, FCGI_BUFFER_SIZE) == -1) {
return -1;
}
fcgi_buffer->size = 0;
memset(fcgi_buffer->data, 0, (size_t)padding);
if (send_directly(fcgi_buffer->sock, (char*)fcgi_buffer->data, padding) == -1) {
return -1;
} else if (send_fcgi_buffer(fcgi_buffer, buffer + FCGI_BUFFER_SIZE, size - FCGI_BUFFER_SIZE) == -1) {
return -1;
}
} else if (buffer == NULL) {
static gboolean
set_ypad (GtkSourceGutter *gutter,
gint ypad,
gboolean resize)
{
return set_padding (gutter, &gutter->priv->ypad, ypad, "ypad", resize);
}
static gboolean
set_xpad (GtkSourceGutter *gutter,
gint xpad,
gboolean resize)
{
return set_padding (gutter, &gutter->priv->xpad, xpad, "xpad", resize);
}
static gboolean
set_ypad (GtkSourceGutterRenderer *renderer,
gint ypad)
{
return set_padding (renderer,
&renderer->priv->ypad,
ypad,
"ypad");
}
static gboolean
set_xpad (GtkSourceGutterRenderer *renderer,
gint xpad)
{
return set_padding (renderer,
&renderer->priv->xpad,
xpad,
"xpad");
}
static void
gltk_spinner_set_property(GObject* object, guint property_id, const GValue* value, GParamSpec* pspec)
{
GltkSpinner* self = GLTK_SPINNER(object);
USING_PRIVATE(self);
switch (property_id)
{
case PROP_MODEL:
{
GltkSpinnerModel* model = GLTK_SPINNER_MODEL(g_value_get_object(value));
priv->hbox = gltk_hbox_new(1);
g_object_ref(model);
priv->model = model;
//initialize the wheels
priv->wheels = g_new(Wheel, priv->model->levels);
int i;
for (i = 0; i < priv->model->levels; i++)
{
Wheel* wheel = priv->wheels + i;
wheel->vbox = gltk_vbox_new(0);
wheel->scrollable = gltk_scrollable_new();
g_object_ref(wheel->vbox);
g_object_ref(wheel->scrollable);
gltk_scrollable_set_widget(GLTK_SCROLLABLE(wheel->scrollable), wheel->vbox);
gltk_box_append_widget(GLTK_BOX(priv->hbox), wheel->scrollable, TRUE, TRUE);
g_signal_connect(wheel->scrollable, "touch-event", (GCallback)scrollable_touch_event, self);
wheel->items = NULL;
wheel->index = 0;
}
//load our toplevel items from the model
load_items(self, 0, gltk_spinner_model_clone_items(priv->model, priv->model->toplevel));
gltk_bin_set_widget(GLTK_BIN(self), priv->hbox);
}
break;
case PROP_VISIBLE_ITEMS:
{
priv->visibleItems = g_value_get_int(value);
int i;
for (i = 0; i < priv->model->levels; i++)
set_padding(self, &priv->wheels[i]);
gltk_widget_layout(GLTK_WIDGET(object));
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
}
}
void BoxStyle::set_padding(float size)
{
set_padding(size, size, size, size);
}
void BoxStyle::set_padding(float width, float height)
{
set_padding(width, height, width, height);
}
static BOOL TestPrimitiveYUV(BOOL use444)
{
BOOL rc = FALSE;
UINT32 x, y;
UINT32 awidth, aheight;
BYTE* yuv[3] = {0};
UINT32 yuv_step[3];
prim_size_t roi;
BYTE* rgb = NULL;
BYTE* rgb_dst = NULL;
size_t size;
primitives_t* prims = primitives_get();
size_t uvsize, uvwidth;
size_t padding = 10000;
size_t stride;
get_size(&roi.width, &roi.height);
/* Buffers need to be 16x16 aligned. */
awidth = roi.width + 16 - roi.width % 16;
aheight = roi.height + 16 - roi.height % 16;
stride = awidth * sizeof(UINT32);
size = awidth * aheight;
if (use444)
{
uvwidth = awidth;
uvsize = size;
if (!prims || !prims->RGBToYUV444_8u_P3AC4R || !prims->YUV444ToRGB_8u_P3AC4R)
return FALSE;
}
else
{
uvwidth = (awidth + 1) / 2;
uvsize = (aheight + 1) / 2 * uvwidth;
if (!prims || !prims->RGBToYUV420_8u_P3AC4R || !prims->YUV420ToRGB_8u_P3AC4R)
return FALSE;
}
fprintf(stderr, "Running AVC%s on frame size %"PRIu32"x%"PRIu32"\n", use444 ? "444" : "420",
roi.width, roi.height);
/* Test RGB to YUV444 conversion and vice versa */
if (!(rgb = set_padding(size * sizeof(UINT32), padding)))
goto fail;
if (!(rgb_dst = set_padding(size * sizeof(UINT32), padding)))
goto fail;
if (!(yuv[0] = set_padding(size, padding)))
goto fail;
if (!(yuv[1] = set_padding(uvsize, padding)))
goto fail;
if (!(yuv[2] = set_padding(uvsize, padding)))
goto fail;
for (y = 0; y < roi.height; y++)
{
BYTE* line = &rgb[y * stride];
for (x = 0; x < roi.width; x++)
{
line[x * 4 + 0] = 0x81;
line[x * 4 + 1] = 0x33;
line[x * 4 + 2] = 0xAB;
line[x * 4 + 3] = 0xFF;
}
}
yuv_step[0] = awidth;
yuv_step[1] = uvwidth;
yuv_step[2] = uvwidth;
if (use444)
{
if (prims->RGBToYUV444_8u_P3AC4R(rgb, PIXEL_FORMAT_BGRA32,
stride, yuv, yuv_step,
&roi) != PRIMITIVES_SUCCESS)
goto fail;
}
else if (prims->RGBToYUV420_8u_P3AC4R(rgb, PIXEL_FORMAT_BGRA32,
stride, yuv, yuv_step,
&roi) != PRIMITIVES_SUCCESS)
goto fail;
if (!check_padding(rgb, size * sizeof(UINT32), padding, "rgb"))
goto fail;
if ((!check_padding(yuv[0], size, padding, "Y")) ||
(!check_padding(yuv[1], uvsize, padding, "U")) ||
(!check_padding(yuv[2], uvsize, padding, "V")))
goto fail;
if (use444)
{
if (prims->YUV444ToRGB_8u_P3AC4R((const BYTE**)yuv, yuv_step, rgb_dst, stride,
PIXEL_FORMAT_BGRA32,
&roi) != PRIMITIVES_SUCCESS)
goto fail;
}
else if (prims->YUV420ToRGB_8u_P3AC4R((const BYTE**)yuv, yuv_step, rgb_dst,
stride, PIXEL_FORMAT_BGRA32, &roi) != PRIMITIVES_SUCCESS)
goto fail;
if (!check_padding(rgb_dst, size * sizeof(UINT32), padding, "rgb dst"))
goto fail;
if ((!check_padding(yuv[0], size, padding, "Y")) ||
(!check_padding(yuv[1], uvsize, padding, "U")) ||
(!check_padding(yuv[2], uvsize, padding, "V")))
goto fail;
for (y = 0; y < roi.height; y++)
{
BYTE* srgb = &rgb[y * stride];
BYTE* drgb = &rgb_dst[y * stride];
if (!similar(srgb, drgb, roi.width * sizeof(UINT32)))
goto fail;
}
rc = TRUE;
fail:
free_padding(rgb, padding);
free_padding(rgb_dst, padding);
free_padding(yuv[0], padding);
free_padding(yuv[1], padding);
free_padding(yuv[2], padding);
return rc;
}
/* Create 2 pseudo YUV420 frames of same size.
* Combine them and check, if the data is at the expected position. */
static BOOL TestPrimitiveYUVCombine(void)
{
UINT32 x, y, i;
UINT32 awidth, aheight;
BOOL rc = FALSE;
BYTE* luma[3] = { 0 };
BYTE* chroma[3] = { 0 };
BYTE* yuv[3] = { 0 };
BYTE* pmain[3] = { 0 };
BYTE* paux[3] = { 0 };
UINT32 lumaStride[3];
UINT32 chromaStride[3];
UINT32 yuvStride[3];
size_t padding = 10000;
prim_size_t roi;
primitives_t* prims = primitives_get();
get_size(&roi.width, &roi.height);
awidth = roi.width + 16 - roi.width % 16;
aheight = roi.height + 16 - roi.height % 16;
fprintf(stderr, "Running YUVCombine on frame size %"PRIu32"x%"PRIu32" [%"PRIu32"x%"PRIu32"]\n",
roi.width, roi.height, awidth, aheight);
if (!prims || !prims->YUV420CombineToYUV444)
goto fail;
for (x = 0; x < 3; x++)
{
size_t halfStride = ((x > 0) ? awidth / 2 : awidth);
size_t size = aheight * awidth;
size_t halfSize = ((x > 0) ? halfStride * aheight / 2 : awidth * aheight);
yuvStride[x] = awidth;
if (!(yuv[x] = set_padding(size, padding)))
goto fail;
lumaStride[x] = halfStride;
if (!(luma[x] = set_padding(halfSize, padding)))
goto fail;
if (!(pmain[x] = set_padding(halfSize, padding)))
goto fail;
chromaStride[x] = halfStride;
if (!(chroma[x] = set_padding(halfSize, padding)))
goto fail;
if (!(paux[x] = set_padding(halfSize, padding)))
goto fail;
memset(luma[x], 0xAB + 3 * x, halfSize);
memset(chroma[x], 0x80 + 2 * x, halfSize);
if (!check_padding(luma[x], halfSize, padding, "luma"))
goto fail;
if (!check_padding(chroma[x], halfSize, padding, "chroma"))
goto fail;
if (!check_padding(pmain[x], halfSize, padding, "main"))
goto fail;
if (!check_padding(paux[x], halfSize, padding, "aux"))
goto fail;
if (!check_padding(yuv[x], size, padding, "yuv"))
goto fail;
}
if (prims->YUV420CombineToYUV444((const BYTE**)luma, lumaStride,
(const BYTE**)chroma, chromaStride,
yuv, yuvStride, &roi) != PRIMITIVES_SUCCESS)
goto fail;
for (x = 0; x < 3; x++)
{
size_t halfStride = ((x > 0) ? awidth / 2 : awidth);
size_t size = aheight * awidth;
size_t halfSize = ((x > 0) ? halfStride * aheight / 2 : awidth * aheight);
if (!check_padding(luma[x], halfSize, padding, "luma"))
goto fail;
if (!check_padding(chroma[x], halfSize, padding, "chroma"))
goto fail;
if (!check_padding(yuv[x], size, padding, "yuv"))
goto fail;
}
if (prims->YUV444SplitToYUV420((const BYTE**)yuv, yuvStride, pmain, lumaStride,
paux, chromaStride, &roi) != PRIMITIVES_SUCCESS)
goto fail;
for (x = 0; x < 3; x++)
{
size_t halfStride = ((x > 0) ? awidth / 2 : awidth);
size_t size = aheight * awidth;
size_t halfSize = ((x > 0) ? halfStride * aheight / 2 : awidth * aheight);
if (!check_padding(pmain[x], halfSize, padding, "main"))
goto fail;
if (!check_padding(paux[x], halfSize, padding, "aux"))
goto fail;
if (!check_padding(yuv[x], size, padding, "yuv"))
goto fail;
}
for (i = 0; i < 3; i++)
{
for (y = 0; y < roi.height; y++)
{
UINT32 w = roi.width;
UINT32 lstride = lumaStride[i];
UINT32 cstride = chromaStride[i];
if (i > 0)
{
w = (roi.width + 3) / 4;
if (roi.height > (roi.height + 1) / 2)
continue;
}
if (!similar(luma[i] + y * lstride,
pmain[i] + y * lstride,
w))
goto fail;
/* Need to ignore lines of destination Y plane,
* if the lines are not a multiple of 16
* as the UV planes are packed in 8 line stripes. */
if (i == 0)
{
/* TODO: This check is not perfect, it does not
* include the last V lines packed to the Y
* frame. */
UINT32 rem = roi.height % 16;
if (y > roi.height - rem)
continue;
}
if (!similar(chroma[i] + y * cstride,
paux[i] + y * cstride,
w))
goto fail;
}
}
rc = TRUE;
fail:
for (x = 0; x < 3; x++)
{
free_padding(yuv[x], padding);
free_padding(luma[x], padding);
free_padding(chroma[x], padding);
free_padding(pmain[x], padding);
free_padding(paux[x], padding);
}
return rc;
}
widget::widget(const variant& v, game_logic::formula_callable* e)
: environ_(e), w_(0), h_(0), x_(0), y_(0), zorder_(0),
true_x_(0), true_y_(0), disabled_(false), disabled_opacity_(v["disabled_opacity"].as_int(127)),
tooltip_displayed_(false), id_(v["id"].as_string_default()), align_h_(HALIGN_LEFT), align_v_(VALIGN_TOP),
tooltip_display_delay_(v["tooltip_delay"].as_int(500)), tooltip_ticks_(INT_MAX),
resolution_(v["frame_size"].as_int(0)), display_alpha_(v["alpha"].as_int(256)),
pad_w_(0), pad_h_(0), claim_mouse_events_(v["claim_mouse_events"].as_bool(true)),
draw_with_object_shader_(v["draw_with_object_shader"].as_bool(true))
{
set_alpha(display_alpha_ < 0 ? 0 : (display_alpha_ > 256 ? 256 : display_alpha_));
if(v.has_key("width")) {
w_ = v["width"].as_int();
}
if(v.has_key("height")) {
h_ = v["height"].as_int();
}
if(v.has_key("wh")) {
std::vector<int> iv = v["wh"].as_list_int();
ASSERT_LOG(iv.size() == 2, "WH attribute must be 2 integer elements.");
w_ = iv[0];
h_ = iv[1];
}
if(v.has_key("rect")) {
std::vector<int> r = v["rect"].as_list_int();
ASSERT_LOG(r.size() == 4, "Four values must be supplied to the rect attribute");
set_loc(r[0], r[1]);
set_dim(r[2], r[3]);
}
if(v.has_key("draw_area")) {
std::vector<int> r = v["draw_area"].as_list_int();
ASSERT_LOG(r.size() == 4, "Four values must be supplied to the rect attribute");
set_loc(r[0], r[1]);
set_dim(r[2], r[3]);
}
if(v.has_key("x")) {
true_x_ = x_ = v["x"].as_int();
}
if(v.has_key("y")) {
true_y_ = y_ = v["y"].as_int();
}
if(v.has_key("xy")) {
std::vector<int> iv = v["xy"].as_list_int();
ASSERT_LOG(iv.size() == 2, "XY attribute must be 2 integer elements.");
true_x_ = x_ = iv[0];
true_y_ = y_ = iv[1];
}
zorder_ = v["zorder"].as_int(0);
if(v.has_key("on_process")) {
on_process_ = boost::bind(&widget::process_delegate, this);
ffl_on_process_ = get_environment()->create_formula(v["on_process"]);
}
if(v.has_key("tooltip")) {
if(v["tooltip"].is_string()) {
SDL_Color color = v.has_key("tooltip_color") ? graphics::color(v["tooltip_color"]).as_sdl_color() : graphics::color_yellow();
set_tooltip(v["tooltip"].as_string(), v["tooltip_size"].as_int(18), color, v["tooltip_font"].as_string_default());
} else if(v["tooltip"].is_map()) {
SDL_Color color = v["tooltip"].has_key("color") ? graphics::color(v["tooltip"]["color"]).as_sdl_color() : graphics::color_yellow();
set_tooltip(v["tooltip"]["text"].as_string(), v["tooltip"]["size"].as_int(18), color, v["tooltip"]["font"].as_string_default());
} else {
ASSERT_LOG(false, "Specify the tooltip as a string, e.g. \"tooltip\":\"Text to display on mouseover\", "
"or a map, e.g. \"tooltip\":{\"text\":\"Text to display.\", \"size\":14}");
}
}
visible_ = v["visible"].as_bool(true);
if(v.has_key("align_h")) {
std::string align = v["align_h"].as_string();
if(align == "left") {
align_h_ = HALIGN_LEFT;
} else if(align == "middle" || align == "center" || align == "centre") {
align_h_ = HALIGN_CENTER;
} else if(align == "right") {
align_h_ = HALIGN_RIGHT;
} else {
ASSERT_LOG(false, "Invalid align_h attribute given: " << align);
}
}
if(v.has_key("align_v")) {
std::string align = v["align_v"].as_string();
if(align == "top") {
align_v_ = VALIGN_TOP;
} else if(align == "middle" || align == "center" || align == "centre") {
align_v_ = VALIGN_CENTER;
} else if(align == "bottom") {
align_v_ = VALIGN_BOTTOM;
} else {
ASSERT_LOG(false, "Invalid align_v attribute given: " << align);
}
}
disabled_ = !v["enabled"].as_bool(true);
if(v.has_key("frame")) {
set_frame_set(v["frame"].as_string());
}
if(v.has_key("frame_padding")) {
ASSERT_LOG(v["frame_padding"].is_list() && v["frame_padding"].num_elements() == 2, "'pad' must be two element list");
set_padding(v["frame_padding"][0].as_int(), v["frame_padding"][1].as_int());
}
if(v.has_key("frame_pad_width")) {
set_padding(v["frame_pad_width"].as_int(), get_pad_height());
}
if(v.has_key("frame_pad_height")) {
set_padding(get_pad_width(), v["frame_pad_height"].as_int());
}
recalc_loc();
}
static void
load_items(GltkSpinner* spinner, int level, GList* items)
{
USING_PRIVATE(spinner);
Wheel* wheel = priv->wheels + level;
//clean up an old mess
if (wheel->items)
{
gltk_spinner_model_free_items(priv->model, wheel->items);
g_object_unref(wheel->vbox);
wheel->vbox = gltk_vbox_new(0);
g_object_ref(wheel->vbox);
gltk_scrollable_set_widget(GLTK_SCROLLABLE(wheel->scrollable), wheel->vbox);
}
//make a new one
wheel->items = items;
int itemHeight = priv->itemHeight;
GList* pItems = wheel->items;
while (pItems)
{
GltkSpinnerModelItem* item = (GltkSpinnerModelItem*)pItems->data;
GltkWidget* label = gltk_label_new(item->text);
GLTK_LABEL(label)->color.r = 0.0f;
GLTK_LABEL(label)->color.g = 0.0f;
GLTK_LABEL(label)->color.b = 0.0f;
gltk_box_append_widget(GLTK_BOX(wheel->vbox), label, FALSE, FALSE);
GltkSize size;
gltk_widget_size_request(label, &size);
if (size.height > itemHeight)
itemHeight = size.height;
size.width = -1;
size.height = priv->itemHeight;
gltk_widget_set_size_request(label, size);
pItems = pItems->next;
}
//if our max height changed, relayout and resize
if (itemHeight > priv->itemHeight)
{
priv->itemHeight = itemHeight;
priv->heightChanged = TRUE;
gltk_widget_layout(GLTK_WIDGET(spinner));
}
//select a specific item
int len = g_list_length(wheel->items);
if (wheel->index >= len - 1)
wheel->index = len-1;
if (wheel->index < 0)
wheel->index = 0;
set_selected_index(spinner, level, wheel->index);
//set allowable amount to scroll past the vbox
set_padding(spinner, wheel);
//either signal that an item was selected or recurse until we do
if (level == priv->model->levels-1)
{
g_object_ref(spinner);
g_signal_emit(spinner, signals[ITEM_SELECTED], 0);
g_object_unref(spinner);
}
else
{
load_items(spinner, level+1, gltk_spinner_model_get_items(priv->model, level, wheel->index));
}
}
int s3fs::Crypto::pwriteAES(int fd, const char *buf, size_t buflen, off_t offset)
{
char readBlock[AES_BLOCK_SIZE];
unsigned char writeBlock[AES_BLOCK_SIZE];
unsigned char buffer[AES_BLOCK_SIZE];
size_t offsetIndex = offset % AES_BLOCK_SIZE;
size_t readOffset = offset - offsetIndex;
size_t writeOffset = readOffset;
size_t bufIndex = 0;
bool newfile = false;
int bytesRead = 0;
int bytesWritten = 0;
int enclen = 0;
struct stat st;
memset(readBlock, 0, AES_BLOCK_SIZE);
memset(writeBlock, 0, AES_BLOCK_SIZE);
memset(buffer, 0, AES_BLOCK_SIZE);
do {
if(!newfile)
{
if(fstatAES(fd, &st) != 0)
return 1;
bytesRead = preadAES(fd, readBlock, AES_BLOCK_SIZE, readOffset);
if(bytesRead <= 0)
{
newfile = true;
continue;
}
memcpy(buffer, readBlock, bytesRead); //Fill the buffer with contents from the readBlock
if(bufIndex <= 0)
{
memcpy((buffer + offsetIndex), (buf + bufIndex), (AES_BLOCK_SIZE - offsetIndex));
enclen += (bytesRead + ((buflen - bufIndex) >= AES_BLOCK_SIZE) ? AES_BLOCK_SIZE : (buflen - bufIndex));
bufIndex += (AES_BLOCK_SIZE - offsetIndex);
}
else
{
memcpy(buffer, (buf + bufIndex), ((buflen - bufIndex) >= AES_BLOCK_SIZE) ? AES_BLOCK_SIZE : (buflen - bufIndex));
enclen += ((buflen - bufIndex) >= AES_BLOCK_SIZE) ? AES_BLOCK_SIZE : (buflen - bufIndex);
bufIndex += ((buflen - bufIndex) >= AES_BLOCK_SIZE) ? AES_BLOCK_SIZE : (buflen - bufIndex);
}
//Set padding if needed
if(enclen < AES_BLOCK_SIZE && ((st.st_size - buflen) < AES_BLOCK_SIZE))
{
set_padding(buffer, enclen);
int padlen = get_padding(buffer);
// FGPRINT("s3fs::Crypto Encrypted padding length %d\n", padlen);
}
else if (enclen == AES_BLOCK_SIZE && bufIndex == buflen)
{
encrypt_block(buffer, AES_BLOCK_SIZE, writeBlock);
bytesWritten = pwrite(fd, &writeBlock, AES_BLOCK_SIZE, writeOffset);
memset(buffer, 0, AES_BLOCK_SIZE);
set_padding(buffer, 0);
int padlen = get_padding(buffer);
// FGPRINT("s3fs::Crypto Encrypted padding length %d\n", padlen);
}
encrypt_block(buffer, AES_BLOCK_SIZE, writeBlock);
bytesWritten = pwrite(fd, &writeBlock, AES_BLOCK_SIZE, writeOffset);
writeOffset += bytesWritten;
readOffset += bytesRead;
}
else
{
memset(buffer, 0, AES_BLOCK_SIZE);
memcpy(buffer, (buf + bufIndex), ((buflen - bufIndex) >= AES_BLOCK_SIZE) ? AES_BLOCK_SIZE : (buflen - bufIndex));
enclen += ((buflen - bufIndex) >= AES_BLOCK_SIZE) ? AES_BLOCK_SIZE : (buflen - bufIndex);
bufIndex += ((buflen - bufIndex) >= AES_BLOCK_SIZE) ? AES_BLOCK_SIZE : (buflen - bufIndex);
if(enclen < AES_BLOCK_SIZE)
{
set_padding(buffer, enclen);
int padlen = get_padding(buffer);
// FGPRINT("s3fs::Crypto Encrypted padding length %d\n", padlen);
}
else if (enclen == AES_BLOCK_SIZE && bufIndex == buflen)
{
encrypt_block(buffer, AES_BLOCK_SIZE, writeBlock);
bytesWritten = pwrite(fd, &writeBlock, AES_BLOCK_SIZE, writeOffset);
writeOffset += bytesWritten;
memset(buffer, 0, AES_BLOCK_SIZE);
set_padding(buffer, 0);
int padlen = get_padding(buffer);
// FGPRINT("s3fs::Crypto Encrypted padding length %d\n", padlen);
}
encrypt_block(buffer, AES_BLOCK_SIZE, writeBlock);
bytesWritten = pwrite(fd, &writeBlock, AES_BLOCK_SIZE, writeOffset);
writeOffset += bytesWritten;
}
memset(readBlock, 0, AES_BLOCK_SIZE);
memset(writeBlock, 0, AES_BLOCK_SIZE);
memset(buffer, 0, AES_BLOCK_SIZE);
enclen = 0;
} while(bufIndex < buflen);
return bufIndex;
}
