FSINFO3res *nfsproc3_fsinfo_3_svc(FSINFO3args * argp, struct svc_req * rqstp)
{
static FSINFO3res result;
char *path;
unsigned int maxdata;
if (get_socket_type(rqstp) == SOCK_STREAM)
maxdata = NFS_MAXDATA_TCP;
else
maxdata = NFS_MAXDATA_UDP;
PREP(path, argp->fsroot);
result.FSINFO3res_u.resok.obj_attributes = get_post_cached(rqstp);
result.status = NFS3_OK;
result.FSINFO3res_u.resok.rtmax = maxdata;
result.FSINFO3res_u.resok.rtpref = maxdata;
result.FSINFO3res_u.resok.rtmult = 4096;
result.FSINFO3res_u.resok.wtmax = maxdata;
result.FSINFO3res_u.resok.wtpref = maxdata;
result.FSINFO3res_u.resok.wtmult = 4096;
result.FSINFO3res_u.resok.dtpref = 4096;
result.FSINFO3res_u.resok.maxfilesize = ~0ULL;
result.FSINFO3res_u.resok.time_delta.seconds = backend_time_delta_seconds;
result.FSINFO3res_u.resok.time_delta.nseconds = 0;
result.FSINFO3res_u.resok.properties = backend_fsinfo_properties;
return &result;
}
static void
gtk2perl_cell_layout_set_cell_data_func (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
GtkCellLayoutDataFunc func,
gpointer func_data,
GDestroyNotify destroy)
{
GET_METHOD_OR_DIE (cell_layout, "SET_CELL_DATA_FUNC");
{
SV *code_sv, *data_sv;
PREP (cell_layout);
XPUSHs (sv_2mortal (newSVGtkCellRenderer (cell)));
if (func) {
create_callback (func, func_data, destroy,
&code_sv, &data_sv);
XPUSHs (sv_2mortal (code_sv));
XPUSHs (sv_2mortal (data_sv));
}
CALL;
FINISH;
}
}
RMDIR3res *nfsproc3_rmdir_3_svc(RMDIR3args * argp, struct svc_req * rqstp)
{
static RMDIR3res result;
char *path;
char obj[NFS_MAXPATHLEN];
int res;
PREP(path, argp->object.dir);
result.status =
join(cat_name(path, argp->object.name, obj), exports_rw());
cluster_lookup(obj, rqstp, &result.status);
if (result.status == NFS3_OK) {
change_readdir_cookie();
res = backend_rmdir(obj);
if (res == -1)
result.status = rmdir_err();
}
/* overlaps with resfail */
result.RMDIR3res_u.resok.dir_wcc.before = get_pre_cached();
result.RMDIR3res_u.resok.dir_wcc.after = get_post_stat(path, rqstp);
return &result;
}
READLINK3res *nfsproc3_readlink_3_svc(READLINK3args * argp,
struct svc_req * rqstp)
{
static READLINK3res result;
char *path;
static char buf[NFS_MAXPATHLEN];
int res;
PREP(path, argp->symlink);
res = backend_readlink(path, buf, NFS_MAXPATHLEN - 1);
if (res == -1)
result.status = readlink_err();
else {
/* readlink does not NULL-terminate */
buf[res] = 0;
result.status = NFS3_OK;
result.READLINK3res_u.resok.data = buf;
}
/* overlaps with resfail */
result.READLINK3res_u.resok.symlink_attributes =
get_post_stat(path, rqstp);
return &result;
}
bool
tst2_srv_t::init ()
{
bool rc = true;
if (!mysql.connect ("okws_db_tst2", "okws", "localhost", "abc123")) {
TWARN (mysql.error ());
rc = false;
} else if (!(_q_get = PREP("SELECT id,d,i,d2 FROM tst2 WHERE s = ?")) ||
!(_q_put = PREP("INSERT INTO tst2(s,d,i,d2) VALUES(?,?,?,?)")) ||
!(_q_mget = PREP("SELECT SLEEP(?/1000),id,d,i,d2 "
"FROM tst2 ORDER BY RAND() "
"LIMIT ?"))) {
rc = false;
}
return rc;
}
WRITE3res *nfsproc3_write_3_svc(WRITE3args * argp, struct svc_req * rqstp)
{
static WRITE3res result;
char *path;
int fd, res, res_close;
PREP(path, argp->file);
result.status = join(is_reg(), exports_rw());
/* handle write of owned files */
write_by_owner(rqstp, st_cache);
if (result.status == NFS3_OK) {
/* We allow caching of the fd only for unstable writes. This is to
prevent generating a new write verifier for failed stable writes,
when the fd was not in the cache. Besides, for stable writes, the
fd will be removed from the cache by fd_close() below, so adding
it to and removing it from the cache is just a waste of CPU cycles
*/
fd = fd_open(path, argp->file, UNFS3_FD_WRITE,
(argp->stable == UNSTABLE));
if (fd != -1) {
res =
backend_pwrite(fd, argp->data.data_val, argp->data.data_len,
(off64_t)argp->offset);
/* close for real if not UNSTABLE write */
if (argp->stable == UNSTABLE)
res_close = fd_close(fd, UNFS3_FD_WRITE, FD_CLOSE_VIRT);
else
res_close = fd_close(fd, UNFS3_FD_WRITE, FD_CLOSE_REAL);
/* we always do fsync(), never fdatasync() */
if (argp->stable == DATA_SYNC)
argp->stable = FILE_SYNC;
if (res != -1 && res_close != -1) {
result.WRITE3res_u.resok.count = res;
result.WRITE3res_u.resok.committed = argp->stable;
memcpy(result.WRITE3res_u.resok.verf, wverf,
NFS3_WRITEVERFSIZE);
} else {
/* error during write or close */
result.status = write_write_err();
}
} else
/* could not open for writing */
result.status = write_open_err();
}
/* overlaps with resfail */
result.WRITE3res_u.resok.file_wcc.before = get_pre_cached();
result.WRITE3res_u.resok.file_wcc.after = get_post_stat(path, rqstp);
return &result;
}
static void
gtk2perl_cell_layout_clear (GtkCellLayout *cell_layout)
{
GET_METHOD_OR_DIE (cell_layout, "CLEAR");
{
PREP (cell_layout);
CALL;
FINISH;
}
}
READDIR3res *nfsproc3_readdir_3_svc(READDIR3args * argp,
struct svc_req * rqstp)
{
static READDIR3res result;
char *path;
PREP(path, argp->dir);
result = read_dir(path, argp->cookie, argp->cookieverf, argp->count);
result.READDIR3res_u.resok.dir_attributes = get_post_stat(path, rqstp);
return &result;
}
static void
gtk2perl_cell_layout_clear_attributes (GtkCellLayout *cell_layout,
GtkCellRenderer *cell)
{
GET_METHOD_OR_DIE (cell_layout, "CLEAR_ATTRIBUTES");
{
PREP (cell_layout);
XPUSHs (sv_2mortal (newSVGtkCellRenderer (cell)));
CALL;
FINISH;
}
}
SYMLINK3res *nfsproc3_symlink_3_svc(SYMLINK3args * argp,
struct svc_req * rqstp)
{
static SYMLINK3res result;
char *path;
pre_op_attr pre;
post_op_attr post;
char obj[NFS_MAXPATHLEN];
int res;
mode_t new_mode;
PREP(path, argp->where.dir);
pre = get_pre_cached();
result.status =
join3(cat_name(path, argp->where.name, obj),
atomic_attr(argp->symlink.symlink_attributes), exports_rw());
cluster_create(obj, rqstp, &result.status);
if (argp->symlink.symlink_attributes.mode.set_it == TRUE)
new_mode = create_mode(argp->symlink.symlink_attributes);
else {
/* default rwxrwxrwx */
new_mode =
S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP |
S_IROTH | S_IWOTH | S_IXOTH;
}
if (result.status == NFS3_OK) {
umask(~new_mode);
res = backend_symlink(argp->symlink.symlink_data, obj);
umask(0);
if (res == -1)
result.status = symlink_err();
else {
result.SYMLINK3res_u.resok.obj =
fh_extend_type(argp->where.dir, obj, S_IFLNK);
result.SYMLINK3res_u.resok.obj_attributes =
get_post_cached(rqstp);
}
}
post = get_post_attr(path, argp->where.dir, rqstp);
/* overlaps with resfail */
result.SYMLINK3res_u.resok.dir_wcc.before = pre;
result.SYMLINK3res_u.resok.dir_wcc.after = post;
return &result;
}
static void
gtk2perl_cell_layout_pack_end (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
gboolean expand)
{
GET_METHOD_OR_DIE (cell_layout, "PACK_END");
{
PREP (cell_layout);
XPUSHs (sv_2mortal (newSVGtkCellRenderer (cell)));
XPUSHs (sv_2mortal (boolSV (expand)));
CALL;
FINISH;
}
}
static void
gtk2perl_cell_layout_reorder (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
gint position)
{
GET_METHOD_OR_DIE (cell_layout, "REORDER");
{
PREP (cell_layout);
XPUSHs (sv_2mortal (newSVGtkCellRenderer (cell)));
XPUSHs (sv_2mortal (newSViv (position)));
CALL;
FINISH;
}
}
GETATTR3res *nfsproc3_getattr_3_svc(GETATTR3args * argp,
struct svc_req * rqstp)
{
static GETATTR3res result;
char *path;
post_op_attr post;
PREP(path, argp->object);
post = get_post_cached(rqstp);
result.status = NFS3_OK;
result.GETATTR3res_u.resok.obj_attributes =
post.post_op_attr_u.attributes;
return &result;
}
LOOKUP3res *nfsproc3_lookup_3_svc(LOOKUP3args * argp, struct svc_req * rqstp)
{
static LOOKUP3res result;
unfs3_fh_t *fh;
char *path;
char obj[NFS_MAXPATHLEN];
backend_statstruct buf;
int res;
uint32 gen;
PREP(path, argp->what.dir);
result.status = cat_name(path, argp->what.name, obj);
cluster_lookup(obj, rqstp, &result.status);
if (result.status == NFS3_OK) {
res = backend_lstat(obj, &buf);
if (res == -1)
result.status = lookup_err();
else {
if (strcmp(argp->what.name, ".") == 0 ||
strcmp(argp->what.name, "..") == 0) {
fh = fh_comp_ptr(obj, rqstp, 0);
} else {
gen = backend_get_gen(buf, FD_NONE, obj);
fh = fh_extend(argp->what.dir, buf.st_dev, buf.st_ino, gen);
fh_cache_add(buf.st_dev, buf.st_ino, obj);
}
if (fh) {
result.LOOKUP3res_u.resok.object.data.data_len =
fh_length(fh);
result.LOOKUP3res_u.resok.object.data.data_val = (char *) fh;
result.LOOKUP3res_u.resok.obj_attributes =
get_post_buf(buf, rqstp);
} else {
/* path was too long */
result.status = NFS3ERR_NAMETOOLONG;
}
}
}
/* overlaps with resfail */
result.LOOKUP3res_u.resok.dir_attributes = get_post_stat(path, rqstp);
return &result;
}
static void
gtk2perl_cell_layout_add_attribute (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
const gchar *attribute,
gint column)
{
GET_METHOD_OR_DIE (cell_layout, "ADD_ATTRIBUTE");
{
PREP (cell_layout);
XPUSHs (sv_2mortal (newSVGtkCellRenderer (cell)));
XPUSHs (sv_2mortal (newSVGChar (attribute)));
XPUSHs (sv_2mortal (newSViv (column)));
CALL;
FINISH;
}
}
FSSTAT3res *nfsproc3_fsstat_3_svc(FSSTAT3args * argp, struct svc_req * rqstp)
{
static FSSTAT3res result;
char *path;
backend_statvfsstruct buf;
int res;
PREP(path, argp->fsroot);
/* overlaps with resfail */
result.FSSTAT3res_u.resok.obj_attributes = get_post_cached(rqstp);
res = backend_statvfs(path, &buf);
if (res == -1) {
/* statvfs fell on its nose */
if ((exports_opts & OPT_REMOVABLE) && export_point(path)) {
/* Removable media export point; probably no media inserted.
Return dummy values. */
result.status = NFS3_OK;
result.FSSTAT3res_u.resok.tbytes = 0;
result.FSSTAT3res_u.resok.fbytes = 0;
result.FSSTAT3res_u.resok.abytes = 0;
result.FSSTAT3res_u.resok.tfiles = 0;
result.FSSTAT3res_u.resok.ffiles = 0;
result.FSSTAT3res_u.resok.afiles = 0;
result.FSSTAT3res_u.resok.invarsec = 0;
} else {
result.status = NFS3ERR_IO;
}
} else {
result.status = NFS3_OK;
result.FSSTAT3res_u.resok.tbytes =
(uint64) buf.f_blocks * buf.f_frsize;
result.FSSTAT3res_u.resok.fbytes =
(uint64) buf.f_bfree * buf.f_frsize;
result.FSSTAT3res_u.resok.abytes =
(uint64) buf.f_bavail * buf.f_frsize;
result.FSSTAT3res_u.resok.tfiles = buf.f_files;
result.FSSTAT3res_u.resok.ffiles = buf.f_ffree;
result.FSSTAT3res_u.resok.afiles = buf.f_ffree;
result.FSSTAT3res_u.resok.invarsec = 0;
}
return &result;
}
MKNOD3res *nfsproc3_mknod_3_svc(MKNOD3args * argp, struct svc_req * rqstp)
{
static MKNOD3res result;
char *path;
pre_op_attr pre;
post_op_attr post;
char obj[NFS_MAXPATHLEN];
int res;
mode_t new_mode = 0;
dev_t dev = 0;
PREP(path, argp->where.dir);
pre = get_pre_cached();
result.status =
join3(cat_name(path, argp->where.name, obj),
mknod_args(argp->what, obj, &new_mode, &dev), exports_rw());
cluster_create(obj, rqstp, &result.status);
if (result.status == NFS3_OK) {
if (argp->what.type == NF3CHR || argp->what.type == NF3BLK)
res = backend_mknod(obj, new_mode, dev); /* device */
else if (argp->what.type == NF3FIFO)
res = backend_mkfifo(obj, new_mode); /* FIFO */
else
res = backend_mksocket(obj, new_mode); /* socket */
if (res == -1) {
result.status = mknod_err();
} else {
result.MKNOD3res_u.resok.obj =
fh_extend_type(argp->where.dir, obj,
type_to_mode(argp->what.type));
result.MKNOD3res_u.resok.obj_attributes = get_post_cached(rqstp);
}
}
post = get_post_attr(path, argp->where.dir, rqstp);
/* overlaps with resfail */
result.MKNOD3res_u.resok.dir_wcc.before = pre;
result.MKNOD3res_u.resok.dir_wcc.after = post;
return &result;
}
RENAME3res *nfsproc3_rename_3_svc(RENAME3args * argp, struct svc_req * rqstp)
{
static RENAME3res result;
char *from;
char *to;
char from_obj[NFS_MAXPATHLEN];
char to_obj[NFS_MAXPATHLEN];
pre_op_attr pre;
post_op_attr post;
int res;
PREP(from, argp->from.dir);
pre = get_pre_cached();
result.status =
join(cat_name(from, argp->from.name, from_obj), exports_rw());
cluster_lookup(from_obj, rqstp, &result.status);
to = fh_decomp(argp->to.dir);
if (result.status == NFS3_OK) {
result.status =
join(cat_name(to, argp->to.name, to_obj),
exports_compat(to, rqstp));
cluster_create(to_obj, rqstp, &result.status);
if (result.status == NFS3_OK) {
change_readdir_cookie();
res = backend_rename(from_obj, to_obj);
if (res == -1)
result.status = rename_err();
}
}
post = get_post_attr(from, argp->from.dir, rqstp);
/* overlaps with resfail */
result.RENAME3res_u.resok.fromdir_wcc.before = pre;
result.RENAME3res_u.resok.fromdir_wcc.after = post;
result.RENAME3res_u.resok.todir_wcc.before = get_pre_cached();
result.RENAME3res_u.resok.todir_wcc.after = get_post_stat(to, rqstp);
return &result;
}
ACCESS3res *nfsproc3_access_3_svc(ACCESS3args * argp, struct svc_req * rqstp)
{
static ACCESS3res result;
char *path;
post_op_attr post;
mode_t mode;
int newaccess = 0;
PREP(path, argp->object);
post = get_post_cached(rqstp);
mode = post.post_op_attr_u.attributes.mode;
if (access(path, R_OK) != -1)
newaccess |= ACCESS3_READ;
if (access(path, W_OK) != -1)
newaccess |= ACCESS3_MODIFY | ACCESS3_EXTEND;
if (access(path, X_OK) != -1) {
newaccess |= ACCESS3_EXECUTE;
if (opt_readable_executables)
newaccess |= ACCESS3_READ;
}
/* root is allowed everything */
if (get_uid(rqstp) == 0)
newaccess |= ACCESS3_READ | ACCESS3_MODIFY | ACCESS3_EXTEND;
/* adjust if directory */
if (post.post_op_attr_u.attributes.type == NF3DIR) {
if (newaccess & (ACCESS3_READ | ACCESS3_EXECUTE))
newaccess |= ACCESS3_LOOKUP;
if (newaccess & ACCESS3_MODIFY)
newaccess |= ACCESS3_DELETE;
newaccess &= ~ACCESS3_EXECUTE;
}
result.status = NFS3_OK;
result.ACCESS3res_u.resok.access = newaccess & argp->access;
result.ACCESS3res_u.resok.obj_attributes = post;
return &result;
}
SETATTR3res *nfsproc3_setattr_3_svc(SETATTR3args * argp,
struct svc_req * rqstp)
{
static SETATTR3res result;
pre_op_attr pre;
char *path;
PREP(path, argp->object);
pre = get_pre_cached();
result.status = join(in_sync(argp->guard, pre), exports_rw());
if (result.status == NFS3_OK)
result.status = set_attr(path, argp->object, argp->new_attributes);
/* overlaps with resfail */
result.SETATTR3res_u.resok.obj_wcc.before = pre;
result.SETATTR3res_u.resok.obj_wcc.after = get_post_stat(path, rqstp);
return &result;
}
PATHCONF3res *nfsproc3_pathconf_3_svc(PATHCONF3args * argp,
struct svc_req * rqstp)
{
static PATHCONF3res result;
char *path;
PREP(path, argp->object);
result.PATHCONF3res_u.resok.obj_attributes = get_post_cached(rqstp);
result.status = NFS3_OK;
result.PATHCONF3res_u.resok.linkmax = 0xFFFFFFFF;
result.PATHCONF3res_u.resok.name_max = NFS_MAXPATHLEN;
result.PATHCONF3res_u.resok.no_trunc = TRUE;
result.PATHCONF3res_u.resok.chown_restricted = FALSE;
result.PATHCONF3res_u.resok.case_insensitive =
backend_pathconf_case_insensitive;
result.PATHCONF3res_u.resok.case_preserving = TRUE;
return &result;
}
LINK3res *nfsproc3_link_3_svc(LINK3args * argp, struct svc_req * rqstp)
{
static LINK3res result;
char *path, *old;
pre_op_attr pre;
post_op_attr post;
char obj[NFS_MAXPATHLEN];
int res;
PREP(path, argp->link.dir);
pre = get_pre_cached();
result.status = join(cat_name(path, argp->link.name, obj), exports_rw());
cluster_create(obj, rqstp, &result.status);
old = fh_decomp(argp->file);
if (old && result.status == NFS3_OK) {
result.status = exports_compat(old, rqstp);
if (result.status == NFS3_OK) {
res = backend_link(old, obj);
if (res == -1)
result.status = link_err();
}
} else if (!old)
result.status = NFS3ERR_STALE;
post = get_post_attr(path, argp->link.dir, rqstp);
/* overlaps with resfail */
result.LINK3res_u.resok.file_attributes = get_post_stat(old, rqstp);
result.LINK3res_u.resok.linkdir_wcc.before = pre;
result.LINK3res_u.resok.linkdir_wcc.after = post;
return &result;
}
static GList*
gtk2perl_cell_layout_get_cells (GtkCellLayout *cell_layout)
{
GList * cells = NULL;
GET_METHOD (cell_layout, "GET_CELLS");
if (METHOD_EXISTS) {
int count;
PREP (cell_layout);
PUTBACK;
count = call_sv ((SV *) GvCV (slot), G_ARRAY);
SPAGAIN;
while (count > 0) {
SV * sv = POPs;
cells = g_list_prepend (cells, SvGtkCellRenderer (sv));
count--;
}
PUTBACK;
FINISH;
}
return cells;
}
COMMIT3res *nfsproc3_commit_3_svc(COMMIT3args * argp, struct svc_req * rqstp)
{
static COMMIT3res result;
char *path;
int res;
PREP(path, argp->file);
result.status = join(is_reg(), exports_rw());
if (result.status == NFS3_OK) {
res = fd_sync(argp->file);
if (res != -1)
memcpy(result.COMMIT3res_u.resok.verf, wverf, NFS3_WRITEVERFSIZE);
else
/* error during fsync() or close() */
result.status = NFS3ERR_IO;
}
/* overlaps with resfail */
result.COMMIT3res_u.resfail.file_wcc.before = get_pre_cached();
result.COMMIT3res_u.resfail.file_wcc.after = get_post_stat(path, rqstp);
return &result;
}
MKDIR3res *nfsproc3_mkdir_3_svc(MKDIR3args * argp, struct svc_req * rqstp)
{
static MKDIR3res result;
char *path;
pre_op_attr pre;
post_op_attr post;
char obj[NFS_MAXPATHLEN];
int res;
PREP(path, argp->where.dir);
pre = get_pre_cached();
result.status =
join3(cat_name(path, argp->where.name, obj),
atomic_attr(argp->attributes), exports_rw());
cluster_create(obj, rqstp, &result.status);
if (result.status == NFS3_OK) {
res = backend_mkdir(obj, create_mode(argp->attributes));
if (res == -1)
result.status = mkdir_err();
else {
result.MKDIR3res_u.resok.obj =
fh_extend_type(argp->where.dir, obj, S_IFDIR);
result.MKDIR3res_u.resok.obj_attributes = get_post_cached(rqstp);
}
}
post = get_post_attr(path, argp->where.dir, rqstp);
/* overlaps with resfail */
result.MKDIR3res_u.resok.dir_wcc.before = pre;
result.MKDIR3res_u.resok.dir_wcc.after = post;
return &result;
}
static FT_Error
TA_table_build_prep(FT_Byte** prep,
FT_ULong* prep_len,
SFNT* sfnt,
FONT* font)
{
SFNT_Table* glyf_table = &font->tables[sfnt->glyf_idx];
glyf_Data* data = (glyf_Data*)glyf_table->data;
/* XXX: make this work for more than 256 styles */
FT_Byte num_used_styles = (FT_Byte)data->num_used_styles;
FT_Int i;
FT_Byte* buf = NULL;
FT_Byte* buf_new;
FT_UInt buf_len;
FT_UInt buf_new_len;
FT_UInt len;
FT_Byte* bufp = NULL;
if (font->x_height_snapping_exceptions)
{
bufp = TA_sfnt_build_number_set(sfnt, &buf,
font->x_height_snapping_exceptions);
if (!bufp)
return FT_Err_Out_Of_Memory;
}
buf_len = (FT_UInt)(bufp - buf);
buf_new_len = buf_len;
if (font->hinting_limit)
buf_new_len += sizeof (PREP(hinting_limit_a))
+ 2
+ sizeof (PREP(hinting_limit_b));
buf_new_len += sizeof (PREP(store_funits_to_pixels));
if (font->x_height_snapping_exceptions)
buf_new_len += sizeof (PREP(test_exception_a));
buf_new_len += sizeof (PREP(align_top_a))
+ (num_used_styles > 6 ? num_used_styles + 3
: num_used_styles + 2)
+ sizeof (PREP(align_top_b));
buf_new_len += sizeof (PREP(loop_cvt_a))
+ (num_used_styles > 3 ? 2 * num_used_styles + 3
: 2 * num_used_styles + 2)
+ sizeof (PREP(loop_cvt_b))
+ (num_used_styles > 3 ? 2 * num_used_styles + 3
: 2 * num_used_styles + 2)
+ sizeof (PREP(loop_cvt_c));
if (font->x_height_snapping_exceptions)
buf_new_len += sizeof (PREP(test_exception_b));
buf_new_len += sizeof (PREP(store_vwidth_data_a))
+ 1
+ sizeof (PREP(store_vwidth_data_b))
+ (num_used_styles > 6 ? 2 * (num_used_styles + 1) + 2
: 2 * (num_used_styles + 1) + 1)
+ sizeof (PREP(store_vwidth_data_c))
+ 1
+ sizeof (PREP(store_vwidth_data_d))
+ (num_used_styles > 6 ? 2 * (num_used_styles + 1) + 2
: 2 * (num_used_styles + 1) + 1)
+ sizeof (PREP(store_vwidth_data_e));
buf_new_len += sizeof (PREP(set_smooth_or_strong_a))
+ 1
+ sizeof (PREP(set_smooth_or_strong_b))
+ 1
+ sizeof (PREP(set_smooth_or_strong_c))
+ 1
+ sizeof (PREP(set_smooth_or_strong_d));
buf_new_len += (num_used_styles > 3 ? 2 * num_used_styles + 3
: 2 * num_used_styles + 2)
+ sizeof (PREP(round_blues));
buf_new_len += sizeof (PREP(set_dropout_mode));
buf_new_len += sizeof (PREP(reset_component_counter));
if (font->control_data_head)
buf_new_len += sizeof (PREP(adjust_delta_exceptions));
buf_new_len += sizeof (PREP(set_default_cvs_values));
/* buffer length must be a multiple of four */
len = (buf_new_len + 3) & ~3U;
buf_new = (FT_Byte*)realloc(buf, len);
if (!buf_new)
{
free(buf);
return FT_Err_Out_Of_Memory;
}
buf = buf_new;
/* pad end of buffer with zeros */
buf[len - 1] = 0x00;
buf[len - 2] = 0x00;
buf[len - 3] = 0x00;
/* copy remaining cvt program into buffer */
/* and fill in the missing variables */
bufp = buf + buf_len;
if (font->hinting_limit)
{
COPY_PREP(hinting_limit_a);
*(bufp++) = HIGH(font->hinting_limit);
*(bufp++) = LOW(font->hinting_limit);
COPY_PREP(hinting_limit_b);
}
COPY_PREP(store_funits_to_pixels);
if (font->x_height_snapping_exceptions)
COPY_PREP(test_exception_a);
COPY_PREP(align_top_a);
if (num_used_styles > 6)
{
BCI(NPUSHB);
BCI(num_used_styles + 2);
}
else
BCI(PUSHB_1 - 1 + num_used_styles + 2);
/* XXX: make this work for offsets > 255 */
for (i = TA_STYLE_MAX - 1; i >= 0; i--)
{
if (data->style_ids[i] == 0xFFFFU)
continue;
*(bufp++) = CVT_X_HEIGHT_BLUE_OFFSET(i) >= 0xFFFFU
? 0
: (unsigned char)CVT_X_HEIGHT_BLUE_OFFSET(i);
}
*(bufp++) = num_used_styles;
COPY_PREP(align_top_b);
COPY_PREP(loop_cvt_a);
if (num_used_styles > 3)
{
BCI(NPUSHB);
BCI(2 * num_used_styles + 2);
}
else
BCI(PUSHB_1 - 1 + 2 * num_used_styles + 2);
/* XXX: make this work for offsets > 255 */
for (i = TA_STYLE_MAX - 1; i >= 0; i--)
{
if (data->style_ids[i] == 0xFFFFU)
continue;
/* don't loop over artificial blue zones */
*(bufp++) = (unsigned char)CVT_VERT_STANDARD_WIDTH_OFFSET(i);
*(bufp++) = (unsigned char)(
1
+ CVT_VERT_WIDTHS_SIZE(i)
+ (CVT_BLUES_SIZE(i) > 1 ? CVT_BLUES_SIZE(i) - 2 : 0));
}
*(bufp++) = num_used_styles;
COPY_PREP(loop_cvt_b);
if (num_used_styles > 3)
{
BCI(NPUSHB);
BCI(2 * num_used_styles + 2);
}
else
BCI(PUSHB_1 - 1 + 2 * num_used_styles + 2);
/* XXX: make this work for offsets > 255 */
for (i = TA_STYLE_MAX - 1; i >= 0; i--)
{
if (data->style_ids[i] == 0xFFFFU)
continue;
/* don't loop over artificial blue zones */
*(bufp++) = (unsigned char)CVT_BLUE_SHOOTS_OFFSET(i);
*(bufp++) = (unsigned char)(
CVT_BLUES_SIZE(i) > 1 ? CVT_BLUES_SIZE(i) - 2 : 0);
}
*(bufp++) = num_used_styles;
COPY_PREP(loop_cvt_c);
if (font->x_height_snapping_exceptions)
COPY_PREP(test_exception_b);
COPY_PREP(store_vwidth_data_a);
*(bufp++) = (unsigned char)CVT_VWIDTH_OFFSET_DATA(0);
COPY_PREP(store_vwidth_data_b);
if (num_used_styles > 6)
{
BCI(NPUSHW);
BCI(num_used_styles + 2);
}
else
BCI(PUSHW_1 - 1 + num_used_styles + 2);
for (i = TA_STYLE_MAX - 1; i >= 0; i--)
{
if (data->style_ids[i] == 0xFFFFU)
continue;
*(bufp++) = HIGH(CVT_VERT_WIDTHS_OFFSET(i) * 64);
*(bufp++) = LOW(CVT_VERT_WIDTHS_OFFSET(i) * 64);
}
*(bufp++) = HIGH(num_used_styles);
*(bufp++) = LOW(num_used_styles);
COPY_PREP(store_vwidth_data_c);
*(bufp++) = (unsigned char)CVT_VWIDTH_SIZE_DATA(0);
COPY_PREP(store_vwidth_data_d);
if (num_used_styles > 6)
{
BCI(NPUSHW);
BCI(num_used_styles + 2);
}
else
BCI(PUSHW_1 - 1 + num_used_styles + 2);
for (i = TA_STYLE_MAX - 1; i >= 0; i--)
{
if (data->style_ids[i] == 0xFFFFU)
continue;
*(bufp++) = HIGH(CVT_VERT_WIDTHS_SIZE(i) * 64);
*(bufp++) = LOW(CVT_VERT_WIDTHS_SIZE(i) * 64);
}
*(bufp++) = HIGH(num_used_styles);
*(bufp++) = LOW(num_used_styles);
COPY_PREP(store_vwidth_data_e);
COPY_PREP(set_smooth_or_strong_a);
*(bufp++) = font->gray_strong_stem_width ? 100 : 0;
COPY_PREP(set_smooth_or_strong_b);
*(bufp++) = font->gdi_cleartype_strong_stem_width ? 100 : 0;
COPY_PREP(set_smooth_or_strong_c);
*(bufp++) = font->dw_cleartype_strong_stem_width ? 100 : 0;
COPY_PREP(set_smooth_or_strong_d);
if (num_used_styles > 3)
{
BCI(NPUSHB);
BCI(2 * num_used_styles + 2);
}
else
BCI(PUSHB_1 - 1 + 2 * num_used_styles + 2);
/* XXX: make this work for offsets > 255 */
for (i = TA_STYLE_MAX - 1; i >= 0; i--)
{
if (data->style_ids[i] == 0xFFFFU)
continue;
*(bufp++) = (unsigned char)CVT_BLUE_REFS_OFFSET(i);
*(bufp++) = (unsigned char)CVT_BLUES_SIZE(i);
}
*(bufp++) = num_used_styles;
COPY_PREP(round_blues);
COPY_PREP(set_dropout_mode);
COPY_PREP(reset_component_counter);
if (font->control_data_head)
COPY_PREP(adjust_delta_exceptions);
COPY_PREP(set_default_cvs_values);
*prep = buf;
*prep_len = buf_new_len;
return FT_Err_Ok;
}
static FT_Error
TA_table_build_prep(FT_Byte** prep,
FT_ULong* prep_len,
FONT* font)
{
TA_LatinAxis vaxis;
TA_LatinBlue blue_adjustment = NULL;
FT_UInt i;
FT_UInt buf_len = 0;
FT_UInt len;
FT_Byte* buf;
FT_Byte* buf_p;
if (font->loader->hints.metrics->clazz->script == TA_SCRIPT_NONE)
vaxis = NULL;
else
{
vaxis = &((TA_LatinMetrics)font->loader->hints.metrics)->axis[1];
for (i = 0; i < vaxis->blue_count; i++)
{
if (vaxis->blues[i].flags & TA_LATIN_BLUE_ADJUSTMENT)
{
blue_adjustment = &vaxis->blues[i];
break;
}
}
}
if (font->hinting_limit)
buf_len += sizeof (PREP(hinting_limit_a))
+ 2
+ sizeof (PREP(hinting_limit_b));
buf_len += sizeof (PREP(store_0x10000));
if (blue_adjustment)
buf_len += sizeof (PREP(align_top_a))
+ 1
+ sizeof (PREP(align_top_b))
+ (font->increase_x_height ? sizeof (PREP(align_top_c1))
: sizeof (PREP(align_top_c2)))
+ sizeof (PREP(align_top_d))
+ sizeof (PREP(loop_cvt_a))
+ 2
+ sizeof (PREP(loop_cvt_b))
+ 2
+ sizeof (PREP(loop_cvt_c))
+ 2
+ sizeof (PREP(loop_cvt_d));
buf_len += sizeof (PREP(compute_extra_light_a))
+ 1
+ sizeof (PREP(compute_extra_light_b));
if (CVT_BLUES_SIZE(font))
buf_len += sizeof (PREP(round_blues_a))
+ 2
+ sizeof (PREP(round_blues_b));
buf_len += sizeof (PREP(set_dropout_mode));
buf_len += sizeof (PREP(reset_component_counter));
/* buffer length must be a multiple of four */
len = (buf_len + 3) & ~3;
buf = (FT_Byte*)malloc(len);
if (!buf)
return FT_Err_Out_Of_Memory;
/* pad end of buffer with zeros */
buf[len - 1] = 0x00;
buf[len - 2] = 0x00;
buf[len - 3] = 0x00;
/* copy cvt program into buffer and fill in the missing variables */
buf_p = buf;
if (font->hinting_limit)
{
COPY_PREP(hinting_limit_a);
*(buf_p++) = HIGH(font->hinting_limit);
*(buf_p++) = LOW(font->hinting_limit);
COPY_PREP(hinting_limit_b);
}
COPY_PREP(store_0x10000);
if (blue_adjustment)
{
COPY_PREP(align_top_a);
*(buf_p++) = (unsigned char)(CVT_BLUE_SHOOTS_OFFSET(font)
+ blue_adjustment - vaxis->blues);
COPY_PREP(align_top_b);
if (font->increase_x_height)
COPY_PREP(align_top_c1);
else
COPY_PREP(align_top_c2);
COPY_PREP(align_top_d);
COPY_PREP(loop_cvt_a);
*(buf_p++) = (unsigned char)CVT_VERT_WIDTHS_OFFSET(font);
*(buf_p++) = (unsigned char)(CVT_VERT_WIDTHS_OFFSET(font)
+ CVT_VERT_WIDTHS_SIZE(font) - 1);
COPY_PREP(loop_cvt_b);
*(buf_p++) = (unsigned char)CVT_BLUE_REFS_OFFSET(font);
*(buf_p++) = (unsigned char)(CVT_BLUE_REFS_OFFSET(font)
+ CVT_BLUES_SIZE(font) - 1);
COPY_PREP(loop_cvt_c);
*(buf_p++) = (unsigned char)CVT_BLUE_SHOOTS_OFFSET(font);
*(buf_p++) = (unsigned char)(CVT_BLUE_SHOOTS_OFFSET(font)
+ CVT_BLUES_SIZE(font) - 1);
COPY_PREP(loop_cvt_d);
}
COPY_PREP(compute_extra_light_a);
*(buf_p++) = (unsigned char)CVT_VERT_STANDARD_WIDTH_OFFSET(font);
COPY_PREP(compute_extra_light_b);
if (CVT_BLUES_SIZE(font))
{
COPY_PREP(round_blues_a);
*(buf_p++) = (unsigned char)CVT_BLUE_REFS_OFFSET(font);
*(buf_p++) = (unsigned char)(CVT_BLUE_REFS_OFFSET(font)
+ CVT_BLUES_SIZE(font) - 1);
COPY_PREP(round_blues_b);
}
COPY_PREP(set_dropout_mode);
COPY_PREP(reset_component_counter);
*prep = buf;
*prep_len = buf_len;
return FT_Err_Ok;
}
ACCESS3res *nfsproc3_access_3_svc(ACCESS3args * argp, struct svc_req * rqstp)
{
static ACCESS3res result;
char *path;
post_op_attr post;
mode_t mode;
int access = 0;
PREP(path, argp->object);
post = get_post_cached(rqstp);
mode = post.post_op_attr_u.attributes.mode;
/* owner permissions */
if (is_owner(st_cache.st_uid, rqstp)) {
if (mode & S_IRUSR)
access |= ACCESS3_READ;
if (mode & S_IWUSR)
access |= ACCESS3_MODIFY | ACCESS3_EXTEND;
if (mode & S_IXUSR) {
access |= ACCESS3_EXECUTE;
if (opt_readable_executables)
access |= ACCESS3_READ;
}
} else if (has_group(st_cache.st_gid, rqstp)) {
/* group permissions */
if (mode & S_IRGRP)
access |= ACCESS3_READ;
if (mode & S_IWGRP)
access |= ACCESS3_MODIFY | ACCESS3_EXTEND;
if (mode & S_IXGRP) {
access |= ACCESS3_EXECUTE;
if (opt_readable_executables)
access |= ACCESS3_READ;
}
} else {
/* other permissions */
if (mode & S_IROTH)
access |= ACCESS3_READ;
if (mode & S_IWOTH)
access |= ACCESS3_MODIFY | ACCESS3_EXTEND;
if (mode & S_IXOTH) {
access |= ACCESS3_EXECUTE;
if (opt_readable_executables)
access |= ACCESS3_READ;
}
}
/* root is allowed everything */
if (get_uid(rqstp) == 0)
access |= ACCESS3_READ | ACCESS3_MODIFY | ACCESS3_EXTEND;
/* adjust if directory */
if (post.post_op_attr_u.attributes.type == NF3DIR) {
if (access & (ACCESS3_READ | ACCESS3_EXECUTE))
access |= ACCESS3_LOOKUP;
if (access & ACCESS3_MODIFY)
access |= ACCESS3_DELETE;
access &= ~ACCESS3_EXECUTE;
}
result.status = NFS3_OK;
result.ACCESS3res_u.resok.access = access & argp->access;
result.ACCESS3res_u.resok.obj_attributes = post;
return &result;
}
CREATE3res *nfsproc3_create_3_svc(CREATE3args * argp, struct svc_req * rqstp)
{
static CREATE3res result;
char *path;
char obj[NFS_MAXPATHLEN];
sattr3 new_attr;
int fd = -1, res = -1;
backend_statstruct buf;
uint32 gen;
int flags = O_RDWR | O_CREAT | O_TRUNC | O_NONBLOCK;
PREP(path, argp->where.dir);
result.status = join(cat_name(path, argp->where.name, obj), exports_rw());
cluster_create(obj, rqstp, &result.status);
/* GUARDED and EXCLUSIVE maps to Unix exclusive create */
if (argp->how.mode != UNCHECKED)
flags = flags | O_EXCL;
if (argp->how.mode != EXCLUSIVE) {
new_attr = argp->how.createhow3_u.obj_attributes;
result.status = join(result.status, atomic_attr(new_attr));
}
/* Try to open the file */
if (result.status == NFS3_OK) {
if (argp->how.mode != EXCLUSIVE) {
fd = backend_open_create(obj, flags, create_mode(new_attr));
} else {
fd = backend_open_create(obj, flags, create_mode(new_attr));
}
}
if (fd != -1) {
/* Successful open */
res = backend_fstat(fd, &buf);
if (res != -1) {
/* Successful stat */
if (argp->how.mode == EXCLUSIVE) {
/* Save verifier in atime and mtime */
res =
backend_store_create_verifier(obj,
argp->how.createhow3_u.
verf);
}
}
if (res != -1) {
/* So far, so good */
gen = backend_get_gen(buf, fd, obj);
fh_cache_add(buf.st_dev, buf.st_ino, obj);
backend_close(fd);
result.CREATE3res_u.resok.obj =
fh_extend_post(argp->where.dir, buf.st_dev, buf.st_ino, gen);
result.CREATE3res_u.resok.obj_attributes =
get_post_buf(buf, rqstp);
}
if (res == -1) {
/* backend_fstat() or backend_store_create_verifier() failed */
backend_close(fd);
result.status = NFS3ERR_IO;
}
} else if (result.status == NFS3_OK) {
/* open() failed */
if (argp->how.mode == EXCLUSIVE && errno == EEXIST) {
/* Check if verifier matches */
fd = backend_open(obj, O_NONBLOCK);
if (fd != -1) {
res = backend_fstat(fd, &buf);
}
if (res != -1) {
if (backend_check_create_verifier
(&buf, argp->how.createhow3_u.verf)) {
/* The verifier matched. Return success */
gen = backend_get_gen(buf, fd, obj);
fh_cache_add(buf.st_dev, buf.st_ino, obj);
backend_close(fd);
result.CREATE3res_u.resok.obj =
fh_extend_post(argp->where.dir, buf.st_dev,
buf.st_ino, gen);
result.CREATE3res_u.resok.obj_attributes =
get_post_buf(buf, rqstp);
} else {
/* The verifier doesn't match */
result.status = NFS3ERR_EXIST;
}
}
}
if (res == -1) {
result.status = create_err();
}
}
/* overlaps with resfail */
result.CREATE3res_u.resok.dir_wcc.before = get_pre_cached();
result.CREATE3res_u.resok.dir_wcc.after = get_post_stat(path, rqstp);
return &result;
}
READ3res *nfsproc3_read_3_svc(READ3args * argp, struct svc_req * rqstp)
{
static READ3res result;
char *path;
int fd, res;
static char buf[NFS_MAXDATA_TCP + 1];
unsigned int maxdata;
if (get_socket_type(rqstp) == SOCK_STREAM)
maxdata = NFS_MAXDATA_TCP;
else
maxdata = NFS_MAXDATA_UDP;
PREP(path, argp->file);
result.status = is_reg();
/* handle reading of executables */
read_executable(rqstp, st_cache);
/* handle read of owned files */
read_by_owner(rqstp, st_cache);
/* if bigger than rtmax, truncate length */
if (argp->count > maxdata)
argp->count = maxdata;
if (result.status == NFS3_OK) {
fd = fd_open(path, argp->file, UNFS3_FD_READ, TRUE);
if (fd != -1) {
/* read one more to check for eof */
res = backend_pread(fd, buf, argp->count + 1, (off64_t)argp->offset);
/* eof if we could not read one more */
result.READ3res_u.resok.eof = (res <= (int64) argp->count);
/* close for real when hitting eof */
if (result.READ3res_u.resok.eof)
fd_close(fd, UNFS3_FD_READ, FD_CLOSE_REAL);
else {
fd_close(fd, UNFS3_FD_READ, FD_CLOSE_VIRT);
res--;
}
if (res >= 0) {
result.READ3res_u.resok.count = res;
result.READ3res_u.resok.data.data_len = res;
result.READ3res_u.resok.data.data_val = buf;
} else {
/* error during read() */
/* EINVAL means unreadable object */
if (errno == EINVAL)
result.status = NFS3ERR_INVAL;
else
result.status = NFS3ERR_IO;
}
} else
/* opening for read failed */
result.status = read_err();
}
/* overlaps with resfail */
result.READ3res_u.resok.file_attributes = get_post_stat(path, rqstp);
return &result;
}
