int coherent_read(int blocksize, samples_t **buffers) {
int di;
for(di=0; di < ndongles; di++) {
dongles[di].blocksize = blocksize;
dongles[di].buffer = buffers[di];
}
/* generate some dummy I2C traffic to trigger noise source */
CHECK1(rtlsdr_set_tuner_gain(dongles[trigger_id].dev, gain-10));
CHECK1(rtlsdr_set_tuner_gain(dongles[trigger_id].dev, gain));
pthread_mutex_lock(&dongle_m);
dongle_task = DONGLE_READ;
pthread_cond_broadcast(&dongle_c);
pthread_mutex_unlock(&dongle_m);
for(di=0; di < donglesok; di++)
sem_wait(&dongle_sem);
if(coherent_debug)
fprintf(stderr, "Read all\n");
return 0;
err:
return -1;
}
nlopt_opt make_opt(const mxArray *opts, unsigned n)
{
nlopt_opt opt = NULL, local_opt = NULL;
nlopt_algorithm algorithm;
double *tmp = NULL;
unsigned i;
algorithm = (nlopt_algorithm)
struct_val_default(opts, "algorithm", NLOPT_NUM_ALGORITHMS);
CHECK1(((int)algorithm) >= 0 && algorithm < NLOPT_NUM_ALGORITHMS,
"invalid opt.algorithm");
tmp = (double *) mxCalloc(n, sizeof(double));
opt = nlopt_create(algorithm, n);
CHECK1(opt, "nlopt: out of memory");
nlopt_set_lower_bounds(opt, struct_arrval(opts, "lower_bounds", n,
fill(tmp, n, -HUGE_VAL)));
nlopt_set_upper_bounds(opt, struct_arrval(opts, "upper_bounds", n,
fill(tmp, n, +HUGE_VAL)));
nlopt_set_stopval(opt, struct_val_default(opts, "stopval", -HUGE_VAL));
nlopt_set_ftol_rel(opt, struct_val_default(opts, "ftol_rel", 0.0));
nlopt_set_ftol_abs(opt, struct_val_default(opts, "ftol_abs", 0.0));
nlopt_set_xtol_rel(opt, struct_val_default(opts, "xtol_rel", 0.0));
nlopt_set_xtol_abs(opt, struct_arrval(opts, "xtol_abs", n,
fill(tmp, n, 0.0)));
nlopt_set_maxeval(opt, struct_val_default(opts, "maxeval", 0.0) < 0 ?
0 : struct_val_default(opts, "maxeval", 0.0));
nlopt_set_maxtime(opt, struct_val_default(opts, "maxtime", 0.0));
nlopt_set_population(opt, struct_val_default(opts, "population", 0));
nlopt_set_vector_storage(opt, struct_val_default(opts, "vector_storage", 0));
if (struct_arrval(opts, "initial_step", n, NULL))
nlopt_set_initial_step(opt,
struct_arrval(opts, "initial_step", n, NULL));
if (mxGetField(opts, 0, "local_optimizer")) {
const mxArray *local_opts = mxGetField(opts, 0, "local_optimizer");
CHECK1(mxIsStruct(local_opts),
"opt.local_optimizer must be a structure");
CHECK1(local_opt = make_opt(local_opts, n),
"error initializing local optimizer");
nlopt_set_local_optimizer(opt, local_opt);
nlopt_destroy(local_opt); local_opt = NULL;
}
mxFree(tmp);
return opt;
}
static void *dongle_f(void *arg) {
struct dongle_struct *ds = arg;
rtlsdr_dev_t *dev = NULL;
fprintf(stderr, "Initializing %d\n", ds->id);
#ifdef PURKKA1
CHECK1(rtlsdr_open(&dev, (ds->id + 1) % 3));
#define trigger_id 2
#else
CHECK1(rtlsdr_open(&dev, ds->id));
#define trigger_id 0
#endif
ds->dev = dev;
CHECK1(rtlsdr_set_sample_rate(dev, samprate));
CHECK1(rtlsdr_set_dithering(dev, 0));
CHECK1(rtlsdr_set_center_freq(dev, frequency));
CHECK1(rtlsdr_set_tuner_gain_mode(dev, 1));
CHECK1(rtlsdr_set_tuner_gain(dev, gain));
CHECK1(rtlsdr_reset_buffer(dev));
fprintf(stderr, "Initialized %d\n", ds->id);
donglesok++;
for(;;) {
int task;
pthread_mutex_lock(&dongle_m);
if(dongle_task == DONGLE_EXIT)
break;
sem_post(&dongle_sem);
pthread_cond_wait(&dongle_c, &dongle_m);
task = dongle_task;
pthread_mutex_unlock(&dongle_m);
if(task == DONGLE_READ) {
int ret;
int blocksize = ds->blocksize, n_read = 0;
n_read = 0;
errno = 0;
CHECK2(ret = rtlsdr_read_sync(dev, ds->buffer, blocksize, &n_read));
if(ret < 0) {
} else if(n_read < blocksize) {
fprintf(stderr, "Short read %d: %d/%d\n", ds->id, n_read, blocksize);
} else if(coherent_debug) {
fprintf(stderr, "Read %d\n", ds->id);
}
} else if(task == DONGLE_EXIT)
break;
}
donglesok--;
err:
fprintf(stderr, "Exiting %d\n", ds->id);
if(dev)
CHECK2(rtlsdr_close(dev));
sem_post(&dongle_sem);
return NULL;
}
void print_shader_log(GLuint name)
{
int maxlen, len;
CHECK1(glIsShader(name), "GL Name %d is not a shader", name);
glGetShaderiv(name, GL_INFO_LOG_LENGTH, &maxlen);
INFO("GL_INFO_LOG_LENGTH = %d", maxlen);
{
char log[maxlen];
glGetShaderInfoLog(name, maxlen, &len, log);
if (len > 0)
EPRINT("%s\n", log);
}
error:
return;
}
void print_program_log(GLuint name)
{
int maxlen, len;
CHECK1(glIsProgram(name), "GL Name %d is not a program", name);
glGetProgramiv(name, GL_INFO_LOG_LENGTH, &maxlen);
INFO("GL_INFO_LOG_LENGTH = %d", maxlen);
{
char log[maxlen];
glGetProgramInfoLog(name, maxlen, &len, log);
if (len > 0)
EPRINT("%s\n", log);
}
error:
return;
}
int test_main(int, char*[])
{
// An all-blank string is treated as zero.
{
int const n = 9;
double const d[n] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
std::string e(" ");
CHECK0(d, n, e);
}
// Make sure example in comment at top works.
// 1 3; 7 5;0; --> 1 1 1 7 7 0...
{
int const n = 9;
double const d[n] = {1, 1, 1, 7, 7, 0, 0, 0, 0};
std::string e("1 3; 7 5;0");
CHECK0(d, n, e);
}
// Numbers separated by semicolons mean values; the last is
// replicated to fill the vector.
{
int const n = 5;
double const d[n] = {1, 2, 3, 3, 3};
std::string e("1; 2; 3");
CHECK0(d, n, e);
}
// Number-pairs separated by semicolons mean {value, end-duration}.
{
int const n = 10;
double const d[n] = {1, 1, 1, 3, 3, 3, 5, 5, 5, 7};
std::string e("1 3; 3 6; 5 9; 7");
CHECK0(d, n, e);
}
// {value, @ attained_age}
{
int const n = 10;
double const d[n] = {1, 1, 1, 3, 3, 3, 5, 5, 5, 7};
std::string e("1 @93; 3 @96; 5 @99; 7");
CHECK0(d, n, e);
}
// {value, # number_of_years_since_last_interval_endpoint}
{
int const n = 10;
double const d[n] = {1, 1, 1, 3, 3, 3, 5, 5, 5, 7};
std::string e("1 #3; 3 #3; 5 #3; 7");
CHECK0(d, n, e);
}
// {value [|( begin-duration, end-duration ]|) }
// Test [x,y).
{
int const n = 9;
double const d[n] = {1, 1, 3, 3, 3, 5, 7, 7, 7};
std::string e("1 [0, 2); 3 [2, 5); 5 [5, 6); 7");
CHECK0(d, n, e);
}
// Test (x,y].
{
int const n = 9;
double const d[n] = {1, 1, 1, 3, 3, 3, 5, 7, 7};
std::string e("1; 1 (0, 2]; 3 (2, 5]; 5 (5, 6]; 7");
CHECK0(d, n, e);
}
// Test a mixture of all five ways of specifying duration.
{
int const n = 9;
double const d[n] = {1, 1, 1, 1, 2, 3, 4, 5, 5};
std::string e("1 [0, 4); 2 5; 3 #1; 4 @97; 5");
CHECK0(d, n, e);
}
// Test intervals of length one.
{
int const n = 5;
double const d[n] = {1, 3, 5, 7, 7};
std::string e("1 [0, 1); 3 [1, 2); 5 (1, 2]; 7");
CHECK0(d, n, e);
}
// Test empty intervals.
{
int const n = 5;
double const d[n] = {1, 3, 5, 7, 7};
std::string e("1 [0, 1); 3 [1, 1]; 5 (1, 2]; 7");
CHECK0(d, n, e);
}
// Test subtly improper intervals.
{
int const n = 5;
double const d[n] = {0, 0, 0, 0, 0};
std::string e("1 [0, 0); 3 (1, 2); 5 (2, 2]; 7");
CHECK0(d, n, e);
}
// Test grossly improper intervals.
{
int const n = 9;
double const d[n] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
std::string e("1; 9 (2, 0]; 3 [7, 3); 5 (5, 5); 7");
CHECK0(d, n, e);
}
// Test intervals with 'holes'. Since the last element is replicated,
// there can be no 'hole' at the end.
{
int const n = 9;
double const d[n] = {0, 1, 0, 3, 0, 5, 7, 7, 7};
std::string e("1 [1, 2); 3 [3, 3]; 5 (4, 5]; 7");
CHECK0(d, n, e);
}
// Test overlapping intervals.
// TODO ?? Treat these as an error?
{
int const n = 9;
double const d[n] = {1, 1, 1, 3, 3, 5, 5, 7, 7};
std::string e("1; 1 (0, 8]; 3 (2, 7]; 5 (4, 6]; 7");
CHECK0(d, n, e);
}
// Test intervals with decreasing begin-points.
// TODO ?? Should this case be allowed?
{
int const n = 9;
double const d[n] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
std::string e("5 [5, 6); 3 [2, 5); 1 [0, 2); 7");
CHECK0(d, n, e);
}
// Durations with '@' prefix mean attained age.
{
int const n = 10;
double const d[n] = {0, 12, 0, 27, 0, 1, 7, 7, 7, 7};
std::string e("12 [1, @92); 27 [@93, @93]; 1 (@94, 5]; 7");
CHECK0(d, n, e);
}
// Test floating-point values; we choose values that we know
// must be exactly representable on a binary machine, so that a
// simple test for equality suffices.
{
int const n = 10;
double const d[n] = {0, 12.25, 0, 27.875, 0, 1.0625, 7.5, 7.5, 7.5, 7.5};
std::string e("12.25 [1, @92); 27.875 [@93, @93]; 1.0625 (@94, 5]; 7.5");
CHECK0(d, n, e);
}
// {value, @ age} means {value, to-attained-age}
{
int const n = 10;
double const d[n] = {1, 1, 1, 3, 3, 3, 5, 5, 5, 7};
std::string e("1 @93; 3 @96; 5 @99; 7");
CHECK0(d, n, e);
}
// TODO ?? Also support and test:
// additive expressions e.g. retirement-10 ?
// Test construction from vector.
// 1 1 1 2 2 --> 1 [0,3);2 [3,5)
// TODO ?? Test against canonical representation once we define that.
{
int const n = 5;
double const d[n] = {1, 1, 1, 2, 2};
std::vector<double> v(d, d + n);
BOOST_TEST(v == InputSequence(v).linear_number_representation());
}
// Test (enumerative) extra keywords.
{
int const n = 9;
char const* c[n] = {"a", "a", "ccc", "ccc", "b", "b", "b", "b", "b"};
double const d[n] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
std::string e("a[0, 2); ccc [2, 4);b[4, 6);");
std::vector<std::string> k;
k.push_back("not_used");
k.push_back("a");
k.push_back("b");
k.push_back("c");
k.push_back("cc");
k.push_back("ccc");
CHECK1(d, n, e, k, c);
}
// Test numbers mixed with (enumerative) extra keywords.
{
int const n = 9;
char const* c[n] = {"", "", "keyword_00", "keyword_00", "", "", "", "", ""};
double const d[n] = {1, 1, 0, 0, 5, 5, 7, 7, 7};
std::string e("1 [0, 2); keyword_00 [2, 4); 5 [4, 6); 7");
std::vector<std::string> k;
k.push_back("keyword_00");
CHECK1(d, n, e, k, c);
}
// Test numbers mixed with (enumerative) extra keywords, with
// a default keyword.
{
int const n = 10;
char const* c[n] = {"b", "b", "x", "a", "x", "x", "a", "x", "x", "x"};
double const d[n] = { 0, 0, 0, 0, 5, 5, 0, 7, 7, 7};
std::string e("b [0, 2); a [3, 4); 5 [4, 6); a; 7");
std::vector<std::string> k;
k.push_back("a");
k.push_back("b");
k.push_back("x");
std::string w("x");
CHECK2(d, n, e, k, c, w);
}
// TODO ?? Also test keyword as scalar duration.
// Duration keywords: {retirement, maturity}
{
int const n = 10;
double const d[n] = {7, 7, 7, 7, 7, 4, 4, 4, 4, 4};
std::string e("7, retirement; 4");
CHECK0(d, n, e);
InputSequence seq("7, retirement; 4", 10, 90, 95, 0, 2002, 0);
std::vector<ValueInterval> const& i(seq.interval_representation());
BOOST_TEST(e_inception == i[0].begin_mode);
BOOST_TEST(e_retirement == i[0].end_mode );
BOOST_TEST(e_retirement == i[1].begin_mode);
BOOST_TEST(e_maturity == i[1].end_mode );
}
// TODO ?? Also test default keyword.
// TODO ?? Also test keywords-only switch.
return 0;
}
int main(int argc, char *argv[]) {
unsigned int exposure, gain, mode, nzwo, bin, lm;
ASI_CAMERA_INFO prop;
unsigned char *buff;
int bsize, n=0, max = 0;
float sum = 0.0;
int width, height;
if (argc != 9) {
printf("Usage: %s [camera idx] [mode] [bin] [exposure in ms] [gain] [long mode] [w if >0] [h if>0]\n", argv[0]);
exit(1);
}
cidx = strtoul(argv[1], NULL, 0);
mode = strtoul(argv[2], NULL, 0);
bin = strtoul(argv[3], NULL, 0);
exposure = strtoul(argv[4], NULL, 0);
gain = strtoul(argv[5], NULL, 0);
lm = strtoul(argv[6], NULL, 0);
width = strtol(argv[7], NULL, 0);
height = strtol(argv[8], NULL, 0);
nzwo = ASIGetNumOfConnectedCameras();
if (cidx >= nzwo) {
fprintf(stderr, "Camera out of range %d/%d\n", cidx, nzwo);
exit(1);
}
CHECK(ASIGetCameraProperty(&prop, cidx));
CHECK(ASIOpenCamera(cidx));
CHECK(ASIInitCamera(cidx));
if (width <= 0)
width = prop.MaxWidth/bin;
if (height <= 0)
height = prop.MaxHeight/bin;
fprintf(stderr, "%d x %d\n", width, height);
bsize = width * height;
if (mode == 1)
bsize *= 3;
else if (mode == 2)
bsize *= 2;
buff = malloc(bsize);
CHECK(ASISetROIFormat(cidx, width, height, bin, mode));
set_cap(ASI_EXPOSURE, exposure * 1000);
set_cap(ASI_GAIN, gain);
set_cap(ASI_HARDWARE_BIN, ASI_TRUE);
#ifdef SELF_BULK
sb_init(bsize);
#endif
if (lm == 0)
CHECK(ASIStartVideoCapture(cidx));
while (1) {
int r;
struct timespec start, stop;
long delta;
clock_gettime(CLOCK_MONOTONIC, &start);
if (lm == 1) {
ASI_EXPOSURE_STATUS s;
CHECK1(ASIGetExpStatus(cidx, &s));
if (s != ASI_EXP_IDLE && s != ASI_EXP_FAILED) {
fprintf(stderr, "Not idle or failed: %d\n", s);
exit(1);
}
CHECK(ASIStartExposure(cidx, 0));
fprintf(stderr, "START\n");
r = 99; /* timeout */
do {
usleep(10*1000);
clock_gettime(CLOCK_MONOTONIC, &stop);
delta = (stop.tv_sec - start.tv_sec) * 1000 +
(stop.tv_nsec - start.tv_nsec) / 1000000;
CHECK1(ASIGetExpStatus(cidx, &s));
if (s == ASI_EXP_IDLE) {
fprintf(stderr, "start\n");
CHECK(ASIStartExposure(cidx, 0));
}
else if (s == ASI_EXP_SUCCESS) {
r = 0;
fprintf(stderr, "FINISHED\n");
CHECK(ASIGetDataAfterExp(cidx, buff, bsize));
break;
} else if (s == ASI_EXP_FAILED) {
r = 98;
break;
}
else if (s != ASI_EXP_WORKING) {
fprintf(stderr, "Unexpected status\n");
exit(1);
}
} while (delta < 20 * exposure + 500);
}
else {
fprintf(stderr, "ASIGetVideoData\n");
r = ASIGetVideoData(cidx, buff, bsize, 20 * exposure + 500);
clock_gettime(CLOCK_MONOTONIC, &stop);
delta = (stop.tv_sec - start.tv_sec) * 1000 +
(stop.tv_nsec - start.tv_nsec) / 1000000;
}
n++;
if (delta > max)
max = delta;
sum += delta;
fprintf(stderr, ":%2d %6.0f(%6d) %ld\n",
r, sum / n, max, delta);
}
return 0;
}
/* basic testing of all SMB2 setinfo calls
for each call we test that it succeeds, and where possible test
for consistency between the calls.
*/
BOOL torture_smb2_setinfo(struct torture_context *torture)
{
struct smb2_tree *tree;
BOOL ret = True;
TALLOC_CTX *mem_ctx = talloc_new(NULL);
struct smb2_handle handle;
char *fname;
char *fname_new;
union smb_fileinfo finfo2;
union smb_setfileinfo sfinfo;
struct security_ace ace;
struct security_descriptor *sd;
struct dom_sid *test_sid;
NTSTATUS status, status2=NT_STATUS_OK;
const char *call_name;
time_t basetime = (time(NULL) - 86400) & ~1;
int n = time(NULL) % 100;
ZERO_STRUCT(handle);
fname = talloc_asprintf(mem_ctx, BASEDIR "fnum_test_%d.txt", n);
fname_new = talloc_asprintf(mem_ctx, BASEDIR "fnum_test_new_%d.txt", n);
if (!torture_smb2_connection(mem_ctx, &tree)) {
return False;
}
#define RECREATE_FILE(fname) do { \
smb2_util_close(tree, handle); \
status = smb2_create_complex_file(tree, fname, &handle); \
if (!NT_STATUS_IS_OK(status)) { \
printf("(%s) ERROR: open of %s failed (%s)\n", \
__location__, fname, nt_errstr(status)); \
ret = False; \
goto done; \
}} while (0)
#define RECREATE_BOTH do { \
RECREATE_FILE(fname); \
} while (0)
RECREATE_BOTH;
#define CHECK_CALL(call, rightstatus) do { \
call_name = #call; \
sfinfo.generic.level = RAW_SFILEINFO_ ## call; \
sfinfo.generic.in.file.handle = handle; \
status = smb2_setinfo_file(tree, &sfinfo); \
if (!NT_STATUS_EQUAL(status, rightstatus)) { \
printf("(%s) %s - %s (should be %s)\n", __location__, #call, \
nt_errstr(status), nt_errstr(rightstatus)); \
ret = False; \
goto done; \
} \
} while (0)
#define CHECK1(call) \
do { if (NT_STATUS_IS_OK(status)) { \
finfo2.generic.level = RAW_FILEINFO_ ## call; \
finfo2.generic.in.file.handle = handle; \
status2 = smb2_getinfo_file(tree, mem_ctx, &finfo2); \
if (!NT_STATUS_IS_OK(status2)) { \
printf("(%s) %s - %s\n", __location__, #call, nt_errstr(status2)); \
ret = False; \
goto done; \
} \
}} while (0)
#define CHECK_VALUE(call, stype, field, value) do { \
CHECK1(call); \
if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(status2) && finfo2.stype.out.field != value) { \
printf("(%s) %s - %s/%s should be 0x%x - 0x%x\n", __location__, \
call_name, #stype, #field, \
(uint_t)value, (uint_t)finfo2.stype.out.field); \
torture_smb2_all_info(tree, handle); \
ret = False; \
goto done; \
}} while (0)
#define CHECK_TIME(call, stype, field, value) do { \
CHECK1(call); \
if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(status2) && nt_time_to_unix(finfo2.stype.out.field) != value) { \
printf("(%s) %s - %s/%s should be 0x%x - 0x%x\n", __location__, \
call_name, #stype, #field, \
(uint_t)value, \
(uint_t)nt_time_to_unix(finfo2.stype.out.field)); \
printf("\t%s", timestring(mem_ctx, value)); \
printf("\t%s\n", nt_time_string(mem_ctx, finfo2.stype.out.field)); \
torture_smb2_all_info(tree, handle); \
ret = False; \
goto done; \
}} while (0)
#define CHECK_STATUS(status, correct) do { \
if (!NT_STATUS_EQUAL(status, correct)) { \
printf("(%s) Incorrect status %s - should be %s\n", \
__location__, nt_errstr(status), nt_errstr(correct)); \
ret = False; \
goto done; \
}} while (0)
torture_smb2_all_info(tree, handle);
printf("test basic_information level\n");
basetime += 86400;
unix_to_nt_time(&sfinfo.basic_info.in.create_time, basetime + 100);
unix_to_nt_time(&sfinfo.basic_info.in.access_time, basetime + 200);
unix_to_nt_time(&sfinfo.basic_info.in.write_time, basetime + 300);
unix_to_nt_time(&sfinfo.basic_info.in.change_time, basetime + 400);
sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_READONLY;
CHECK_CALL(BASIC_INFORMATION, NT_STATUS_OK);
CHECK_TIME(SMB2_ALL_INFORMATION, all_info2, create_time, basetime + 100);
CHECK_TIME(SMB2_ALL_INFORMATION, all_info2, access_time, basetime + 200);
CHECK_TIME(SMB2_ALL_INFORMATION, all_info2, write_time, basetime + 300);
CHECK_TIME(SMB2_ALL_INFORMATION, all_info2, change_time, basetime + 400);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, attrib, FILE_ATTRIBUTE_READONLY);
printf("a zero time means don't change\n");
unix_to_nt_time(&sfinfo.basic_info.in.create_time, 0);
unix_to_nt_time(&sfinfo.basic_info.in.access_time, 0);
unix_to_nt_time(&sfinfo.basic_info.in.write_time, 0);
unix_to_nt_time(&sfinfo.basic_info.in.change_time, 0);
sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_NORMAL;
CHECK_CALL(BASIC_INFORMATION, NT_STATUS_OK);
CHECK_TIME(SMB2_ALL_INFORMATION, all_info2, create_time, basetime + 100);
CHECK_TIME(SMB2_ALL_INFORMATION, all_info2, access_time, basetime + 200);
CHECK_TIME(SMB2_ALL_INFORMATION, all_info2, write_time, basetime + 300);
CHECK_TIME(SMB2_ALL_INFORMATION, all_info2, change_time, basetime + 400);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, attrib, FILE_ATTRIBUTE_NORMAL);
printf("change the attribute\n");
sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_HIDDEN;
CHECK_CALL(BASIC_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, attrib, FILE_ATTRIBUTE_HIDDEN);
printf("zero attrib means don't change\n");
sfinfo.basic_info.in.attrib = 0;
CHECK_CALL(BASIC_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, attrib, FILE_ATTRIBUTE_HIDDEN);
printf("restore attribute\n");
sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_NORMAL;
CHECK_CALL(BASIC_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, attrib, FILE_ATTRIBUTE_NORMAL);
printf("test disposition_information level\n");
sfinfo.disposition_info.in.delete_on_close = 1;
CHECK_CALL(DISPOSITION_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, delete_pending, 1);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, nlink, 0);
sfinfo.disposition_info.in.delete_on_close = 0;
CHECK_CALL(DISPOSITION_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, delete_pending, 0);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, nlink, 1);
printf("test allocation_information level\n");
sfinfo.allocation_info.in.alloc_size = 0;
CHECK_CALL(ALLOCATION_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, size, 0);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, alloc_size, 0);
sfinfo.allocation_info.in.alloc_size = 4096;
CHECK_CALL(ALLOCATION_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, alloc_size, 4096);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, size, 0);
printf("test end_of_file_info level\n");
sfinfo.end_of_file_info.in.size = 37;
CHECK_CALL(END_OF_FILE_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, size, 37);
sfinfo.end_of_file_info.in.size = 7;
CHECK_CALL(END_OF_FILE_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, size, 7);
printf("test position_information level\n");
sfinfo.position_information.in.position = 123456;
CHECK_CALL(POSITION_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(POSITION_INFORMATION, position_information, position, 123456);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, position, 123456);
printf("test mode_information level\n");
sfinfo.mode_information.in.mode = 2;
CHECK_CALL(MODE_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(MODE_INFORMATION, mode_information, mode, 2);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, mode, 2);
sfinfo.mode_information.in.mode = 1;
CHECK_CALL(MODE_INFORMATION, NT_STATUS_INVALID_PARAMETER);
sfinfo.mode_information.in.mode = 0;
CHECK_CALL(MODE_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(MODE_INFORMATION, mode_information, mode, 0);
printf("test sec_desc level\n");
ZERO_STRUCT(finfo2);
finfo2.query_secdesc.in.secinfo_flags =
SECINFO_OWNER |
SECINFO_GROUP |
SECINFO_DACL;
CHECK1(SEC_DESC);
sd = finfo2.query_secdesc.out.sd;
test_sid = dom_sid_parse_talloc(mem_ctx, "S-1-5-32-1234-5432");
ZERO_STRUCT(ace);
ace.type = SEC_ACE_TYPE_ACCESS_ALLOWED;
ace.flags = 0;
ace.access_mask = SEC_STD_ALL;
ace.trustee = *test_sid;
status = security_descriptor_dacl_add(sd, &ace);
CHECK_STATUS(status, NT_STATUS_OK);
printf("add a new ACE to the DACL\n");
sfinfo.set_secdesc.in.secinfo_flags = finfo2.query_secdesc.in.secinfo_flags;
sfinfo.set_secdesc.in.sd = sd;
CHECK_CALL(SEC_DESC, NT_STATUS_OK);
CHECK1(SEC_DESC);
if (!security_acl_equal(finfo2.query_secdesc.out.sd->dacl, sd->dacl)) {
printf("%s: security descriptors don't match!\n", __location__);
printf("got:\n");
NDR_PRINT_DEBUG(security_descriptor, finfo2.query_secdesc.out.sd);
printf("expected:\n");
NDR_PRINT_DEBUG(security_descriptor, sd);
ret = False;
}
printf("remove it again\n");
status = security_descriptor_dacl_del(sd, test_sid);
CHECK_STATUS(status, NT_STATUS_OK);
sfinfo.set_secdesc.in.secinfo_flags = finfo2.query_secdesc.in.secinfo_flags;
sfinfo.set_secdesc.in.sd = sd;
CHECK_CALL(SEC_DESC, NT_STATUS_OK);
CHECK1(SEC_DESC);
if (!security_acl_equal(finfo2.query_secdesc.out.sd->dacl, sd->dacl)) {
printf("%s: security descriptors don't match!\n", __location__);
printf("got:\n");
NDR_PRINT_DEBUG(security_descriptor, finfo2.query_secdesc.out.sd);
printf("expected:\n");
NDR_PRINT_DEBUG(security_descriptor, sd);
ret = False;
}
done:
status = smb2_util_close(tree, handle);
if (NT_STATUS_IS_ERR(status)) {
printf("Failed to delete %s - %s\n", fname, nt_errstr(status));
}
smb2_util_unlink(tree, fname);
talloc_free(mem_ctx);
return ret;
}
QVariant MetaInfoModel::data(const QModelIndex &index, int role) const
{
if(role == Qt::DisplayRole)
{
switch(index.row() + m_offset)
{
case 0:
return (!index.column()) ? tr("Full Path") : CHECK1(QDir::toNativeSeparators(m_fullInfo->filePath()));
break;
case 1:
return (!index.column()) ? tr("Format") : CHECK1(m_fullInfo->audioBaseInfo());
break;
case 2:
return (!index.column()) ? tr("Container") : CHECK1(m_fullInfo->containerInfo());
break;
case 3:
return (!index.column()) ? tr("Compression") : CHECK1(m_fullInfo->audioCompressInfo());
break;
case 4:
return (!index.column()) ? tr("Duration") : CHECK1(m_fullInfo->durationInfo());
break;
case 5:
return (!index.column()) ? tr("Title") : CHECK1(m_metaInfo->title());
break;
case 6:
return (!index.column()) ? tr("Artist") : CHECK1(m_metaInfo->artist());
break;
case 7:
return (!index.column()) ? tr("Album") : CHECK1(m_metaInfo->album());
break;
case 8:
return (!index.column()) ? tr("Genre") : CHECK1(m_metaInfo->genre());
break;
case 9:
return (!index.column()) ? tr("Year") : CHECK2(m_metaInfo->year());
break;
case 10:
return (!index.column()) ? tr("Position") : ((m_metaInfo->position() == UINT_MAX) ? tr("Generate from list position") : CHECK2(m_metaInfo->position()));
break;
case 11:
return (!index.column()) ? tr("Comment") : CHECK1(m_metaInfo->comment());
break;
default:
return QVariant();
break;
}
}
else if(role == Qt::DecorationRole && index.column() == 0)
{
switch(index.row() + m_offset)
{
case 0:
return QIcon(":/icons/folder_page.png");
break;
case 1:
return QIcon(":/icons/sound.png");
break;
case 2:
return QIcon(":/icons/package.png");
break;
case 3:
return QIcon(":/icons/compress.png");
break;
case 4:
return QIcon(":/icons/clock_play.png");
break;
case 5:
return QIcon(":/icons/music.png");
break;
case 6:
return QIcon(":/icons/user.png");
break;
case 7:
return QIcon(":/icons/cd.png");
break;
case 8:
return QIcon(":/icons/star.png");
break;
case 9:
return QIcon(":/icons/date.png");
break;
case 10:
return QIcon(":/icons/timeline_marker.png");
break;
case 11:
return QIcon(":/icons/comment.png");
break;
default:
return QVariant();
break;
}
}
else if(role == Qt::TextColorRole && index.column() == 1)
{
switch(index.row() + m_offset)
{
case 0:
return CHECK3(m_fullInfo->filePath());
break;
case 1:
return CHECK3(m_fullInfo->audioBaseInfo());
break;
case 2:
return CHECK3(m_fullInfo->containerInfo());
break;
case 3:
return CHECK3(m_fullInfo->audioCompressInfo());
break;
case 4:
return CHECK4(m_fullInfo->durationInfo());
break;
case 5:
return CHECK3(m_metaInfo->title());
break;
case 6:
return CHECK3(m_metaInfo->artist());
break;
case 7:
return CHECK3(m_metaInfo->album());
break;
case 8:
return CHECK3(m_metaInfo->genre());
break;
case 9:
return CHECK4(m_metaInfo->year());
break;
case 10:
return CHECK4(m_metaInfo->position());
break;
case 11:
return CHECK3(m_metaInfo->comment());
break;
default:
return QVariant();
break;
}
}
else
{
return QVariant();
}
}
/* basic testing of all SMB2 setinfo calls
for each call we test that it succeeds, and where possible test
for consistency between the calls.
*/
bool torture_smb2_setinfo(struct torture_context *tctx)
{
struct smb2_tree *tree;
bool ret = true;
struct smb2_handle handle;
char *fname;
union smb_fileinfo finfo2;
union smb_setfileinfo sfinfo;
struct security_ace ace;
struct security_descriptor *sd;
struct dom_sid *test_sid;
NTSTATUS status, status2=NT_STATUS_OK;
const char *call_name;
time_t basetime = (time(NULL) - 86400) & ~1;
int n = time(NULL) % 100;
struct ea_struct ea;
ZERO_STRUCT(handle);
fname = talloc_asprintf(tctx, BASEDIR "fnum_test_%d.txt", n);
if (!torture_smb2_connection(tctx, &tree)) {
return false;
}
#define RECREATE_FILE(fname) do { \
smb2_util_close(tree, handle); \
status = smb2_create_complex_file(tree, fname, &handle); \
if (!NT_STATUS_IS_OK(status)) { \
torture_result(tctx, TORTURE_FAIL, "(%s) ERROR: open of %s failed (%s)\n", \
__location__, fname, nt_errstr(status)); \
ret = false; \
goto done; \
}} while (0)
#define RECREATE_BOTH do { \
RECREATE_FILE(fname); \
} while (0)
RECREATE_BOTH;
#define CHECK_CALL(call, rightstatus) do { \
call_name = #call; \
sfinfo.generic.level = RAW_SFILEINFO_ ## call; \
sfinfo.generic.in.file.handle = handle; \
status = smb2_setinfo_file(tree, &sfinfo); \
if (!NT_STATUS_EQUAL(status, rightstatus)) { \
torture_result(tctx, TORTURE_FAIL, "(%s) %s - %s (should be %s)\n", __location__, #call, \
nt_errstr(status), nt_errstr(rightstatus)); \
ret = false; \
goto done; \
} \
} while (0)
#define CHECK1(call) \
do { if (NT_STATUS_IS_OK(status)) { \
finfo2.generic.level = RAW_FILEINFO_ ## call; \
finfo2.generic.in.file.handle = handle; \
status2 = smb2_getinfo_file(tree, tctx, &finfo2); \
if (!NT_STATUS_IS_OK(status2)) { \
torture_result(tctx, TORTURE_FAIL, "(%s) %s - %s\n", __location__, #call, nt_errstr(status2)); \
ret = false; \
goto done; \
} \
}} while (0)
#define CHECK_VALUE(call, stype, field, value) do { \
CHECK1(call); \
if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(status2) && finfo2.stype.out.field != value) { \
torture_result(tctx, TORTURE_FAIL, "(%s) %s - %s/%s should be 0x%x - 0x%x\n", __location__, \
call_name, #stype, #field, \
(unsigned int)value, (unsigned int)finfo2.stype.out.field); \
torture_smb2_all_info(tree, handle); \
ret = false; \
goto done; \
}} while (0)
#define CHECK_TIME(call, stype, field, value) do { \
CHECK1(call); \
if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(status2) && nt_time_to_unix(finfo2.stype.out.field) != value) { \
torture_result(tctx, TORTURE_FAIL, "(%s) %s - %s/%s should be 0x%x - 0x%x\n", __location__, \
call_name, #stype, #field, \
(unsigned int)value, \
(unsigned int)nt_time_to_unix(finfo2.stype.out.field)); \
torture_warning(tctx, "\t%s", timestring(tctx, value)); \
torture_warning(tctx, "\t%s\n", nt_time_string(tctx, finfo2.stype.out.field)); \
torture_smb2_all_info(tree, handle); \
ret = false; \
goto done; \
}} while (0)
#define CHECK_STATUS(status, correct) do { \
if (!NT_STATUS_EQUAL(status, correct)) { \
torture_result(tctx, TORTURE_FAIL, "(%s) Incorrect status %s - should be %s\n", \
__location__, nt_errstr(status), nt_errstr(correct)); \
ret = false; \
goto done; \
}} while (0)
torture_smb2_all_info(tree, handle);
torture_comment(tctx, "Test basic_information level\n");
basetime += 86400;
unix_to_nt_time(&sfinfo.basic_info.in.create_time, basetime + 100);
unix_to_nt_time(&sfinfo.basic_info.in.access_time, basetime + 200);
unix_to_nt_time(&sfinfo.basic_info.in.write_time, basetime + 300);
unix_to_nt_time(&sfinfo.basic_info.in.change_time, basetime + 400);
sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_READONLY;
CHECK_CALL(BASIC_INFORMATION, NT_STATUS_OK);
CHECK_TIME(SMB2_ALL_INFORMATION, all_info2, create_time, basetime + 100);
CHECK_TIME(SMB2_ALL_INFORMATION, all_info2, access_time, basetime + 200);
CHECK_TIME(SMB2_ALL_INFORMATION, all_info2, write_time, basetime + 300);
CHECK_TIME(SMB2_ALL_INFORMATION, all_info2, change_time, basetime + 400);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, attrib, FILE_ATTRIBUTE_READONLY);
torture_comment(tctx, "a zero time means don't change\n");
unix_to_nt_time(&sfinfo.basic_info.in.create_time, 0);
unix_to_nt_time(&sfinfo.basic_info.in.access_time, 0);
unix_to_nt_time(&sfinfo.basic_info.in.write_time, 0);
unix_to_nt_time(&sfinfo.basic_info.in.change_time, 0);
sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_NORMAL;
CHECK_CALL(BASIC_INFORMATION, NT_STATUS_OK);
CHECK_TIME(SMB2_ALL_INFORMATION, all_info2, create_time, basetime + 100);
CHECK_TIME(SMB2_ALL_INFORMATION, all_info2, access_time, basetime + 200);
CHECK_TIME(SMB2_ALL_INFORMATION, all_info2, write_time, basetime + 300);
CHECK_TIME(SMB2_ALL_INFORMATION, all_info2, change_time, basetime + 400);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, attrib, FILE_ATTRIBUTE_NORMAL);
torture_comment(tctx, "change the attribute\n");
sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_HIDDEN;
CHECK_CALL(BASIC_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, attrib, FILE_ATTRIBUTE_HIDDEN);
torture_comment(tctx, "zero attrib means don't change\n");
sfinfo.basic_info.in.attrib = 0;
CHECK_CALL(BASIC_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, attrib, FILE_ATTRIBUTE_HIDDEN);
torture_comment(tctx, "can't change a file to a directory\n");
sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_DIRECTORY;
CHECK_CALL(BASIC_INFORMATION, NT_STATUS_INVALID_PARAMETER);
torture_comment(tctx, "restore attribute\n");
sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_NORMAL;
CHECK_CALL(BASIC_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, attrib, FILE_ATTRIBUTE_NORMAL);
torture_comment(tctx, "Test disposition_information level\n");
sfinfo.disposition_info.in.delete_on_close = 1;
CHECK_CALL(DISPOSITION_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, delete_pending, 1);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, nlink, 0);
sfinfo.disposition_info.in.delete_on_close = 0;
CHECK_CALL(DISPOSITION_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, delete_pending, 0);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, nlink, 1);
torture_comment(tctx, "Test allocation_information level\n");
sfinfo.allocation_info.in.alloc_size = 0;
CHECK_CALL(ALLOCATION_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, size, 0);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, alloc_size, 0);
sfinfo.allocation_info.in.alloc_size = 4096;
CHECK_CALL(ALLOCATION_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, alloc_size, 4096);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, size, 0);
torture_comment(tctx, "Test end_of_file_info level\n");
sfinfo.end_of_file_info.in.size = 37;
CHECK_CALL(END_OF_FILE_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, size, 37);
sfinfo.end_of_file_info.in.size = 7;
CHECK_CALL(END_OF_FILE_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, size, 7);
torture_comment(tctx, "Test position_information level\n");
sfinfo.position_information.in.position = 123456;
CHECK_CALL(POSITION_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(POSITION_INFORMATION, position_information, position, 123456);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, position, 123456);
torture_comment(tctx, "Test mode_information level\n");
sfinfo.mode_information.in.mode = 2;
CHECK_CALL(MODE_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(MODE_INFORMATION, mode_information, mode, 2);
CHECK_VALUE(SMB2_ALL_INFORMATION, all_info2, mode, 2);
sfinfo.mode_information.in.mode = 1;
CHECK_CALL(MODE_INFORMATION, NT_STATUS_INVALID_PARAMETER);
sfinfo.mode_information.in.mode = 0;
CHECK_CALL(MODE_INFORMATION, NT_STATUS_OK);
CHECK_VALUE(MODE_INFORMATION, mode_information, mode, 0);
torture_comment(tctx, "Test sec_desc level\n");
ZERO_STRUCT(finfo2);
finfo2.query_secdesc.in.secinfo_flags =
SECINFO_OWNER |
SECINFO_GROUP |
SECINFO_DACL;
CHECK1(SEC_DESC);
sd = finfo2.query_secdesc.out.sd;
test_sid = dom_sid_parse_talloc(tctx, SID_NT_AUTHENTICATED_USERS);
ZERO_STRUCT(ace);
ace.type = SEC_ACE_TYPE_ACCESS_ALLOWED;
ace.flags = 0;
ace.access_mask = SEC_STD_ALL;
ace.trustee = *test_sid;
status = security_descriptor_dacl_add(sd, &ace);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(tctx, "add a new ACE to the DACL\n");
sfinfo.set_secdesc.in.secinfo_flags = finfo2.query_secdesc.in.secinfo_flags;
sfinfo.set_secdesc.in.sd = sd;
CHECK_CALL(SEC_DESC, NT_STATUS_OK);
FAIL_UNLESS(smb2_util_verify_sd(tctx, tree, handle, sd));
torture_comment(tctx, "remove it again\n");
status = security_descriptor_dacl_del(sd, test_sid);
CHECK_STATUS(status, NT_STATUS_OK);
sfinfo.set_secdesc.in.secinfo_flags = finfo2.query_secdesc.in.secinfo_flags;
sfinfo.set_secdesc.in.sd = sd;
CHECK_CALL(SEC_DESC, NT_STATUS_OK);
FAIL_UNLESS(smb2_util_verify_sd(tctx, tree, handle, sd));
torture_comment(tctx, "Check zero length EA's behavior\n");
/* Set a new EA. */
sfinfo.full_ea_information.in.eas.num_eas = 1;
ea.flags = 0;
ea.name.private_length = 6;
ea.name.s = "NewEA";
ea.value = data_blob_string_const("testme");
sfinfo.full_ea_information.in.eas.eas = &ea;
CHECK_CALL(FULL_EA_INFORMATION, NT_STATUS_OK);
/* Does it still exist ? */
finfo2.generic.level = RAW_FILEINFO_SMB2_ALL_EAS;
finfo2.generic.in.file.handle = handle;
finfo2.all_eas.in.continue_flags = 1;
status2 = smb2_getinfo_file(tree, tctx, &finfo2);
if (!NT_STATUS_IS_OK(status2)) {
torture_result(tctx, TORTURE_FAIL, "(%s) %s - %s\n", __location__,
"SMB2_ALL_EAS", nt_errstr(status2));
ret = false;
goto done;
}
/* Note on Windows EA name is returned capitalized. */
if (!find_returned_ea(&finfo2, "NewEA", "testme")) {
torture_result(tctx, TORTURE_FAIL, "(%s) Missing EA 'NewEA'\n", __location__);
ret = false;
}
/* Now zero it out (should delete it) */
sfinfo.full_ea_information.in.eas.num_eas = 1;
ea.flags = 0;
ea.name.private_length = 6;
ea.name.s = "NewEA";
ea.value = data_blob_null;
sfinfo.full_ea_information.in.eas.eas = &ea;
CHECK_CALL(FULL_EA_INFORMATION, NT_STATUS_OK);
/* Does it still exist ? */
finfo2.generic.level = RAW_FILEINFO_SMB2_ALL_EAS;
finfo2.generic.in.file.handle = handle;
finfo2.all_eas.in.continue_flags = 1;
status2 = smb2_getinfo_file(tree, tctx, &finfo2);
if (!NT_STATUS_IS_OK(status2)) {
torture_result(tctx, TORTURE_FAIL, "(%s) %s - %s\n", __location__,
"SMB2_ALL_EAS", nt_errstr(status2));
ret = false;
goto done;
}
if (find_returned_ea(&finfo2, "NewEA", NULL)) {
torture_result(tctx, TORTURE_FAIL, "(%s) EA 'NewEA' should be deleted\n", __location__);
ret = false;
}
/* Set a zero length EA. */
sfinfo.full_ea_information.in.eas.num_eas = 1;
ea.flags = 0;
ea.name.private_length = 6;
ea.name.s = "ZeroEA";
ea.value = data_blob_null;
sfinfo.full_ea_information.in.eas.eas = &ea;
CHECK_CALL(FULL_EA_INFORMATION, NT_STATUS_OK);
/* Does it still exist ? */
finfo2.generic.level = RAW_FILEINFO_SMB2_ALL_EAS;
finfo2.generic.in.file.handle = handle;
finfo2.all_eas.in.continue_flags = 1;
status2 = smb2_getinfo_file(tree, tctx, &finfo2);
if (!NT_STATUS_IS_OK(status2)) {
torture_result(tctx, TORTURE_FAIL, "(%s) %s - %s\n", __location__,
"SMB2_ALL_EAS", nt_errstr(status2));
ret = false;
goto done;
}
/* Over SMB2 ZeroEA should not exist. */
if (!find_returned_ea(&finfo2, "EAONE", "VALUE1")) {
torture_result(tctx, TORTURE_FAIL, "(%s) Missing EA 'EAONE'\n", __location__);
ret = false;
}
if (!find_returned_ea(&finfo2, "SECONDEA", "ValueTwo")) {
torture_result(tctx, TORTURE_FAIL, "(%s) Missing EA 'SECONDEA'\n", __location__);
ret = false;
}
if (find_returned_ea(&finfo2, "ZeroEA", NULL)) {
torture_result(tctx, TORTURE_FAIL, "(%s) Found null EA 'ZeroEA'\n", __location__);
ret = false;
}
done:
status = smb2_util_close(tree, handle);
if (NT_STATUS_IS_ERR(status)) {
torture_warning(tctx, "Failed to delete %s - %s\n", fname, nt_errstr(status));
}
smb2_util_unlink(tree, fname);
return ret;
}
int init_sdlgl(void)
{
int status = -1;
GLint success;
SDL_INIT(SDL_INIT_VIDEO);
SDL_GL_SETATTRIBUTE(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SETATTRIBUTE(SDL_GL_CONTEXT_MINOR_VERSION, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
window = SDL_CREATEWINDOW(title, 50, 50, 800, 600, SDL_WINDOW_OPENGL);
gl_context = SDL_GL_CREATECONTEXT(window);
glewExperimental = GL_TRUE;
GLEWINIT();
SDL_GL_SETSWAPINTERVAL(1);
program = glCreateProgram();
GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
const GLchar *vertex_shader_src[] = {
"#version 140\n"
"in vec2 LVertexPos2D;\n"
"void main() {\n"
" gl_Position = vec4(LVertexPos2D.x, LVertexPos2D.y, 0, 1);\n"
"}\n"
};
glShaderSource(vertex_shader, 1, vertex_shader_src, NULL);
glCompileShader(vertex_shader);
success = GL_FALSE;
glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &success);
if (success != GL_TRUE) {
print_shader_log(vertex_shader);
CHECK1(0, "glCompileShader failed: vertex_shader");
}
glAttachShader(program, vertex_shader);
GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
const GLchar *fragment_shader_src[] = {
"#version 140\n"
"out vec4 LFragment;\n"
"void main() {\n"
" LFragment = vec4(1.0, 0.8, 0.6, 1.0);\n"
"}"
};
glShaderSource(fragment_shader, 1, fragment_shader_src, NULL);
glCompileShader(fragment_shader);
success = GL_FALSE;
glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &success);
if (success != GL_TRUE) {
print_shader_log(fragment_shader);
CHECK1(0, "glCompileShader failed: fragment_shader");
}
glAttachShader(program, fragment_shader);
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &success);
if (success != GL_TRUE) {
print_program_log(program);
CHECK1(0, "glLinkProgram failed");
}
vertex_pos_2d_loc = glGetAttribLocation(program, "LVertexPos2D");
CHECK1(vertex_pos_2d_loc != -1, "glGetAttribLocation failed: LVertexPos2D");
glClearColor(0.5f, 0.f, 0.f, 1.f);
GLfloat vertex_data[] = {
0, -.5,
.5, 0,
0, .5,
-.5, 0
};
GLuint index_data[] = { 0, 1, 2, 3 };
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, 2 * 4 * sizeof(GLfloat), vertex_data, GL_STATIC_DRAW);
glGenBuffers(1, &IBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 4 * sizeof(GLuint), index_data, GL_STATIC_DRAW);
// TODO On OS X make sure you bind 0 to the draw framebuffer before swapping the window, otherwise nothing will happen. ???
status = 0;
error:
return status;
}
