~ubuntu-branches/ubuntu/wily/psqlodbc/wily

« back to all changes in this revision

Viewing changes to dlg_wingui.c

  • Committer: Package Import Robot
  • Author(s): Martin Pitt
  • Date: 2013-10-24 07:21:55 UTC
  • mfrom: (16.2.1 trusty-proposed)
  • Revision ID: package-import@ubuntu.com-20131024072155-wpiifm71c317fhxd
Tags: 1:09.02.0100-2ubuntu1
* Merge with Debian unstable. Remaining Ubuntu changes:
  - debian/tests: Disable iodbc test and dependency, as in Ubuntu iodbc and
    unixodbc are not installable in parallel, and iodbc is obsolete and
    should be removed at some point.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#ifdef  WIN32
2
 
/*-------
3
 
 * Module:                      dlg_wingui.c
4
 
 *
5
 
 * Description:         This module contains any specific code for handling
6
 
 *                                      dialog boxes such as driver/datasource options.  Both the
7
 
 *                                      ConfigDSN() and the SQLDriverConnect() functions use
8
 
 *                                      functions in this module.  If you were to add a new option
9
 
 *                                      to any dialog box, you would most likely only have to change
10
 
 *                                      things in here rather than in 2 separate places as before.
11
 
 *
12
 
 * Classes:                     none
13
 
 *
14
 
 * API functions:       none
15
 
 *
16
 
 * Comments:            See "notice.txt" for copyright and license information.
17
 
 *-------
18
 
 */
19
 
/* Multibyte support    Eiji Tokuya 2001-03-15 */
20
 
 
21
 
#include "dlg_specific.h"
22
 
#include "win_setup.h"
23
 
 
24
 
#include "convert.h"
25
 
#include "loadlib.h"
26
 
 
27
 
#include "multibyte.h"
28
 
#include "pgapifunc.h"
29
 
 
30
 
extern GLOBAL_VALUES globals;
31
 
 
32
 
extern HINSTANCE NEAR s_hModule;
33
 
static int      driver_optionsDraw(HWND, const ConnInfo *, int src, BOOL enable);
34
 
static int      driver_options_update(HWND hdlg, ConnInfo *ci, const char *);
35
 
 
36
 
static struct {
37
 
        int     ids;
38
 
        const char * const      modestr;
39
 
} modetab[] = {
40
 
                  {IDS_SSLREQUEST_DISABLE, SSLMODE_DISABLE}
41
 
                , {IDS_SSLREQUEST_ALLOW, SSLMODE_ALLOW}
42
 
                , {IDS_SSLREQUEST_PREFER, SSLMODE_PREFER}
43
 
                , {IDS_SSLREQUEST_REQUIRE, SSLMODE_REQUIRE}
44
 
                , {IDS_SSLREQUEST_VERIFY_CA, SSLMODE_VERIFY_CA}
45
 
                , {IDS_SSLREQUEST_VERIFY_FULL, SSLMODE_VERIFY_FULL}
46
 
        };
47
 
static int      dspcount_bylevel[] = {1, 4, 6};
48
 
 
49
 
void
50
 
SetDlgStuff(HWND hdlg, const ConnInfo *ci)
51
 
{
52
 
        char    buff[MEDIUM_REGISTRY_LEN + 1];
53
 
        BOOL    libpq_exist = FALSE;
54
 
        int     i, dsplevel, selidx, dspcount;
55
 
 
56
 
        /*
57
 
         * If driver attribute NOT present, then set the datasource name and
58
 
         * description
59
 
         */
60
 
        SetDlgItemText(hdlg, IDC_DSNAME, ci->dsn);
61
 
        SetDlgItemText(hdlg, IDC_DESC, ci->desc);
62
 
 
63
 
        SetDlgItemText(hdlg, IDC_DATABASE, ci->database);
64
 
        SetDlgItemText(hdlg, IDC_SERVER, ci->server);
65
 
        SetDlgItemText(hdlg, IDC_USER, ci->username);
66
 
        SetDlgItemText(hdlg, IDC_PASSWORD, ci->password);
67
 
        SetDlgItemText(hdlg, IDC_PORT, ci->port);
68
 
 
69
 
        dsplevel = 0;
70
 
        libpq_exist = SSLLIB_check();
71
 
mylog("libpq_exist=%d\n", libpq_exist);
72
 
        if (libpq_exist)
73
 
        {
74
 
                ShowWindow(GetDlgItem(hdlg, IDC_NOTICE_USER), SW_HIDE);
75
 
                dsplevel = 2;
76
 
        }
77
 
        else
78
 
        {
79
 
mylog("SendMessage CTL_COLOR\n");
80
 
                SendMessage(GetDlgItem(hdlg, IDC_NOTICE_USER), WM_CTLCOLOR, 0, 0);
81
 
#ifdef  USE_SSPI
82
 
                dsplevel = 1;
83
 
#endif /* USE_SSPI */
84
 
        }
85
 
 
86
 
        selidx = -1;
87
 
        for (i = 0; i < sizeof(modetab) / sizeof(modetab[0]); i++)
88
 
        {
89
 
                if (!stricmp(ci->sslmode, modetab[i].modestr))
90
 
                {
91
 
                        selidx = i;
92
 
                        break;
93
 
                }
94
 
        }
95
 
        for (i = dsplevel; i < sizeof(dspcount_bylevel) / sizeof(int); i++)
96
 
        {
97
 
                if (selidx < dspcount_bylevel[i])
98
 
                        break;
99
 
                dsplevel++;
100
 
        }
101
 
        
102
 
        dspcount = dspcount_bylevel[dsplevel];
103
 
        for (i = 0; i < dspcount; i++)
104
 
        {
105
 
                LoadString(GetWindowInstance(hdlg), modetab[i].ids, buff, MEDIUM_REGISTRY_LEN);
106
 
                SendDlgItemMessage(hdlg, IDC_SSLMODE, CB_ADDSTRING, 0, (WPARAM) buff);
107
 
        }
108
 
 
109
 
        SendDlgItemMessage(hdlg, IDC_SSLMODE, CB_SETCURSEL, selidx, (WPARAM) 0);
110
 
}
111
 
 
112
 
 
113
 
void
114
 
GetDlgStuff(HWND hdlg, ConnInfo *ci)
115
 
{
116
 
        int     sslposition;
117
 
 
118
 
        GetDlgItemText(hdlg, IDC_DESC, ci->desc, sizeof(ci->desc));
119
 
 
120
 
        GetDlgItemText(hdlg, IDC_DATABASE, ci->database, sizeof(ci->database));
121
 
        GetDlgItemText(hdlg, IDC_SERVER, ci->server, sizeof(ci->server));
122
 
        GetDlgItemText(hdlg, IDC_USER, ci->username, sizeof(ci->username));
123
 
        GetDlgItemText(hdlg, IDC_PASSWORD, ci->password, sizeof(ci->password));
124
 
        GetDlgItemText(hdlg, IDC_PORT, ci->port, sizeof(ci->port));
125
 
        sslposition = (int)(DWORD)SendMessage(GetDlgItem(hdlg, IDC_SSLMODE), CB_GETCURSEL, 0L, 0L);
126
 
        strncpy_null(ci->sslmode, modetab[sslposition].modestr, sizeof(ci->sslmode));
127
 
}
128
 
 
129
 
 
130
 
static int
131
 
driver_optionsDraw(HWND hdlg, const ConnInfo *ci, int src, BOOL enable)
132
 
{
133
 
        const GLOBAL_VALUES *comval;
134
 
        static BOOL defset = FALSE;
135
 
        static GLOBAL_VALUES defval;
136
 
 
137
 
        switch (src)
138
 
        {
139
 
                case 0:                 /* driver common */
140
 
                        comval = &globals;
141
 
                        break;
142
 
                case 1:                 /* dsn specific */
143
 
                        comval = &(ci->drivers);
144
 
                        break;
145
 
                case 2:                 /* default */
146
 
                        if (!defset)
147
 
                        {
148
 
                                defval.commlog = DEFAULT_COMMLOG;
149
 
                                defval.disable_optimizer = DEFAULT_OPTIMIZER;
150
 
                                defval.ksqo = DEFAULT_KSQO;
151
 
                                defval.unique_index = DEFAULT_UNIQUEINDEX;
152
 
                                defval.onlyread = DEFAULT_READONLY;
153
 
                                defval.use_declarefetch = DEFAULT_USEDECLAREFETCH;
154
 
 
155
 
                                defval.parse = DEFAULT_PARSE;
156
 
                                defval.cancel_as_freestmt = DEFAULT_CANCELASFREESTMT;
157
 
                                defval.debug = DEFAULT_DEBUG;
158
 
 
159
 
                                /* Unknown Sizes */
160
 
                                defval.unknown_sizes = DEFAULT_UNKNOWNSIZES;
161
 
                                defval.text_as_longvarchar = DEFAULT_TEXTASLONGVARCHAR;
162
 
                                defval.unknowns_as_longvarchar = DEFAULT_UNKNOWNSASLONGVARCHAR;
163
 
                                defval.bools_as_char = DEFAULT_BOOLSASCHAR;
164
 
                        }
165
 
                        defset = TRUE;
166
 
                        comval = &defval;
167
 
                        break;
168
 
        }
169
 
 
170
 
        ShowWindow(GetDlgItem(hdlg, DRV_MSG_LABEL2), enable ? SW_SHOW : SW_HIDE);
171
 
        CheckDlgButton(hdlg, DRV_COMMLOG, comval->commlog);
172
 
#ifndef Q_LOG
173
 
        EnableWindow(GetDlgItem(hdlg, DRV_COMMLOG), FALSE);
174
 
#endif /* Q_LOG */
175
 
        CheckDlgButton(hdlg, DRV_OPTIMIZER, comval->disable_optimizer);
176
 
        CheckDlgButton(hdlg, DRV_KSQO, comval->ksqo);
177
 
        CheckDlgButton(hdlg, DRV_UNIQUEINDEX, comval->unique_index);
178
 
        /* EnableWindow(GetDlgItem(hdlg, DRV_UNIQUEINDEX), enable); */
179
 
        CheckDlgButton(hdlg, DRV_READONLY, comval->onlyread);
180
 
        EnableWindow(GetDlgItem(hdlg, DRV_READONLY), enable);
181
 
        CheckDlgButton(hdlg, DRV_USEDECLAREFETCH, comval->use_declarefetch);
182
 
 
183
 
        /* Unknown Sizes clear */
184
 
        CheckDlgButton(hdlg, DRV_UNKNOWN_DONTKNOW, 0);
185
 
        CheckDlgButton(hdlg, DRV_UNKNOWN_LONGEST, 0);
186
 
        CheckDlgButton(hdlg, DRV_UNKNOWN_MAX, 0);
187
 
        /* Unknown (Default) Data Type sizes */
188
 
        switch (comval->unknown_sizes)
189
 
        {
190
 
                case UNKNOWNS_AS_DONTKNOW:
191
 
                        CheckDlgButton(hdlg, DRV_UNKNOWN_DONTKNOW, 1);
192
 
                        break;
193
 
                case UNKNOWNS_AS_LONGEST:
194
 
                        CheckDlgButton(hdlg, DRV_UNKNOWN_LONGEST, 1);
195
 
                        break;
196
 
                case UNKNOWNS_AS_MAX:
197
 
                default:
198
 
                        CheckDlgButton(hdlg, DRV_UNKNOWN_MAX, 1);
199
 
                        break;
200
 
        }
201
 
 
202
 
        CheckDlgButton(hdlg, DRV_TEXT_LONGVARCHAR, comval->text_as_longvarchar);
203
 
        CheckDlgButton(hdlg, DRV_UNKNOWNS_LONGVARCHAR, comval->unknowns_as_longvarchar);
204
 
        CheckDlgButton(hdlg, DRV_BOOLS_CHAR, comval->bools_as_char);
205
 
        CheckDlgButton(hdlg, DRV_PARSE, comval->parse);
206
 
        CheckDlgButton(hdlg, DRV_CANCELASFREESTMT, comval->cancel_as_freestmt);
207
 
        CheckDlgButton(hdlg, DRV_DEBUG, comval->debug);
208
 
#ifndef MY_LOG
209
 
        EnableWindow(GetDlgItem(hdlg, DRV_DEBUG), FALSE);
210
 
#endif /* MY_LOG */
211
 
        SetDlgItemInt(hdlg, DRV_CACHE_SIZE, comval->fetch_max, FALSE);
212
 
        SetDlgItemInt(hdlg, DRV_VARCHAR_SIZE, comval->max_varchar_size, FALSE);
213
 
        SetDlgItemInt(hdlg, DRV_LONGVARCHAR_SIZE, comval->max_longvarchar_size, TRUE);
214
 
        SetDlgItemText(hdlg, DRV_EXTRASYSTABLEPREFIXES, comval->extra_systable_prefixes);
215
 
 
216
 
        /* Driver Connection Settings */
217
 
        SetDlgItemText(hdlg, DRV_CONNSETTINGS, comval->conn_settings);
218
 
        EnableWindow(GetDlgItem(hdlg, DRV_CONNSETTINGS), enable);
219
 
        ShowWindow(GetDlgItem(hdlg, IDPREVPAGE), enable ? SW_HIDE : SW_SHOW);
220
 
        ShowWindow(GetDlgItem(hdlg, IDNEXTPAGE), enable ? SW_HIDE : SW_SHOW);
221
 
        return 0;
222
 
}
223
 
 
224
 
static int
225
 
driver_options_update(HWND hdlg, ConnInfo *ci, const char *updateDriver)
226
 
{
227
 
        GLOBAL_VALUES *comval;
228
 
 
229
 
        if (ci)
230
 
                comval = &(ci->drivers);
231
 
        else
232
 
                comval = &globals;
233
 
        comval->commlog = IsDlgButtonChecked(hdlg, DRV_COMMLOG);
234
 
        comval->disable_optimizer = IsDlgButtonChecked(hdlg, DRV_OPTIMIZER);
235
 
        comval->ksqo = IsDlgButtonChecked(hdlg, DRV_KSQO);
236
 
        comval->unique_index = IsDlgButtonChecked(hdlg, DRV_UNIQUEINDEX);
237
 
        if (!ci)
238
 
        {
239
 
                comval->onlyread = IsDlgButtonChecked(hdlg, DRV_READONLY);
240
 
        }
241
 
        comval->use_declarefetch = IsDlgButtonChecked(hdlg, DRV_USEDECLAREFETCH);
242
 
 
243
 
        /* Unknown (Default) Data Type sizes */
244
 
        if (IsDlgButtonChecked(hdlg, DRV_UNKNOWN_MAX))
245
 
                comval->unknown_sizes = UNKNOWNS_AS_MAX;
246
 
        else if (IsDlgButtonChecked(hdlg, DRV_UNKNOWN_DONTKNOW))
247
 
                comval->unknown_sizes = UNKNOWNS_AS_DONTKNOW;
248
 
        else if (IsDlgButtonChecked(hdlg, DRV_UNKNOWN_LONGEST))
249
 
                comval->unknown_sizes = UNKNOWNS_AS_LONGEST;
250
 
        else
251
 
                comval->unknown_sizes = UNKNOWNS_AS_MAX;
252
 
 
253
 
        comval->text_as_longvarchar = IsDlgButtonChecked(hdlg, DRV_TEXT_LONGVARCHAR);
254
 
        comval->unknowns_as_longvarchar = IsDlgButtonChecked(hdlg, DRV_UNKNOWNS_LONGVARCHAR);
255
 
        comval->bools_as_char = IsDlgButtonChecked(hdlg, DRV_BOOLS_CHAR);
256
 
 
257
 
        comval->parse = IsDlgButtonChecked(hdlg, DRV_PARSE);
258
 
 
259
 
        comval->cancel_as_freestmt = IsDlgButtonChecked(hdlg, DRV_CANCELASFREESTMT);
260
 
        comval->debug = IsDlgButtonChecked(hdlg, DRV_DEBUG);
261
 
 
262
 
        comval->fetch_max = GetDlgItemInt(hdlg, DRV_CACHE_SIZE, NULL, FALSE);
263
 
        comval->max_varchar_size = GetDlgItemInt(hdlg, DRV_VARCHAR_SIZE, NULL, FALSE);
264
 
        comval->max_longvarchar_size = GetDlgItemInt(hdlg, DRV_LONGVARCHAR_SIZE, NULL, TRUE);           /* allows for
265
 
                                                                                                                                                                                                 * SQL_NO_TOTAL */
266
 
 
267
 
        GetDlgItemText(hdlg, DRV_EXTRASYSTABLEPREFIXES, comval->extra_systable_prefixes, sizeof(comval->extra_systable_prefixes));
268
 
 
269
 
        /* Driver Connection Settings */
270
 
        if (!ci)
271
 
                GetDlgItemText(hdlg, DRV_CONNSETTINGS, comval->conn_settings, sizeof(comval->conn_settings));
272
 
 
273
 
        if (updateDriver)
274
 
        {
275
 
                if (writeDriverCommoninfo(ODBCINST_INI, updateDriver, comval) < 0)
276
 
                        MessageBox(hdlg, "impossible to update the values, sorry", "Update Error", MB_ICONEXCLAMATION | MB_OK);
277
 
;
278
 
        }
279
 
 
280
 
        /* fall through */
281
 
        return 0;
282
 
}
283
 
 
284
 
LRESULT         CALLBACK
285
 
driver_optionsProc(HWND hdlg,
286
 
                                   UINT wMsg,
287
 
                                   WPARAM wParam,
288
 
                                   LPARAM lParam)
289
 
{
290
 
        ConnInfo   *ci;
291
 
        char    strbuf[128];
292
 
 
293
 
        switch (wMsg)
294
 
        {
295
 
                case WM_INITDIALOG:
296
 
                        SetWindowLongPtr(hdlg, DWLP_USER, lParam);              /* save for OK etc */
297
 
                        ci = (ConnInfo *) lParam;
298
 
                        LoadString(s_hModule, IDS_ADVANCE_OPTION_DEF, strbuf, sizeof(strbuf)); 
299
 
                        SetWindowText(hdlg, strbuf);
300
 
                        LoadString(s_hModule, IDS_ADVANCE_SAVE, strbuf, sizeof(strbuf)); 
301
 
                        SetWindowText(GetDlgItem(hdlg, IDOK), strbuf);
302
 
                        ShowWindow(GetDlgItem(hdlg, IDAPPLY), SW_HIDE);
303
 
                        driver_optionsDraw(hdlg, ci, 0, TRUE);
304
 
                        break;
305
 
 
306
 
                case WM_COMMAND:
307
 
                        switch (GET_WM_COMMAND_ID(wParam, lParam))
308
 
                        {
309
 
                                case IDOK:
310
 
                                        ci = (ConnInfo *) GetWindowLongPtr(hdlg, DWLP_USER);
311
 
                                        driver_options_update(hdlg, NULL,
312
 
                                                ci ? ci->drivername : NULL);
313
 
 
314
 
                                case IDCANCEL:
315
 
                                        EndDialog(hdlg, GET_WM_COMMAND_ID(wParam, lParam) == IDOK);
316
 
                                        return TRUE;
317
 
 
318
 
                                case IDDEFAULTS:
319
 
                                        driver_optionsDraw(hdlg, NULL, 2, TRUE);
320
 
                                        break;
321
 
                        }
322
 
        }
323
 
 
324
 
        return FALSE;
325
 
}
326
 
 
327
 
#ifdef _HANDLE_ENLIST_IN_DTC_
328
 
static
329
 
HMODULE DtcProc(const char *procname, FARPROC *proc)
330
 
{
331
 
        HMODULE hmodule;
332
 
 
333
 
        *proc = NULL;
334
 
        if (hmodule = LoadLibrary(GetXaLibPath()), NULL != hmodule)
335
 
        {
336
 
mylog("GetProcAddres for %s\n", procname);
337
 
                *proc = GetProcAddress(hmodule, procname);
338
 
        }
339
 
 
340
 
        return hmodule;
341
 
}
342
 
#endif /* _HANDLE_ENLIST_IN_DTC_ */
343
 
 
344
 
LRESULT                 CALLBACK
345
 
global_optionsProc(HWND hdlg,
346
 
                                   UINT wMsg,
347
 
                                   WPARAM wParam,
348
 
                                   LPARAM lParam)
349
 
{
350
 
#ifdef _HANDLE_ENLIST_IN_DTC_
351
 
        HMODULE hmodule;
352
 
        FARPROC proc;
353
 
#endif /* _HANDLE_ENLIST_IN_DTC_ */
354
 
        char logdir[PATH_MAX];
355
 
 
356
 
        switch (wMsg)
357
 
        {
358
 
                case WM_INITDIALOG:
359
 
                        CheckDlgButton(hdlg, DRV_COMMLOG, globals.commlog);
360
 
#ifndef Q_LOG
361
 
                        EnableWindow(GetDlgItem(hdlg, DRV_COMMLOG), FALSE);
362
 
#endif /* Q_LOG */
363
 
                        CheckDlgButton(hdlg, DRV_DEBUG, globals.debug);
364
 
#ifndef MY_LOG
365
 
                        EnableWindow(GetDlgItem(hdlg, DRV_DEBUG), FALSE);
366
 
#endif /* MY_LOG */
367
 
                        getLogDir(logdir, sizeof(logdir));
368
 
                        SetDlgItemText(hdlg, DS_LOGDIR, logdir);
369
 
#ifdef _HANDLE_ENLIST_IN_DTC_
370
 
                        hmodule = DtcProc("GetMsdtclog", &proc);
371
 
                        if (proc)
372
 
                        {
373
 
                                INT_PTR res = (*proc)();
374
 
                                CheckDlgButton(hdlg, DRV_DTCLOG, 0 != res);
375
 
                        }
376
 
                        else
377
 
                                EnableWindow(GetDlgItem(hdlg, DRV_DTCLOG), FALSE);
378
 
                        if (hmodule)
379
 
                                FreeLibrary(hmodule);
380
 
#else
381
 
                        ShowWindow(GetDlgItem(hdlg, DRV_DTCLOG), SW_HIDE);
382
 
#endif /* _HANDLE_ENLIST_IN_DTC_ */
383
 
                        break;
384
 
 
385
 
                case WM_COMMAND:
386
 
                        switch (GET_WM_COMMAND_ID(wParam, lParam))
387
 
                        {
388
 
                                case IDOK:
389
 
                                        globals.commlog = IsDlgButtonChecked(hdlg, DRV_COMMLOG);
390
 
                                        globals.debug = IsDlgButtonChecked(hdlg, DRV_DEBUG);
391
 
                                        if (writeDriverCommoninfo(ODBCINST_INI, NULL, &globals) < 0)
392
 
                                                MessageBox(hdlg, "Sorry, impossible to update the values\nWrite permission seems to be needed", "Update Error", MB_ICONEXCLAMATION | MB_OK);
393
 
                                        GetDlgItemText(hdlg, DS_LOGDIR, logdir, sizeof(logdir));
394
 
                                        setLogDir(logdir[0] ? logdir : NULL);
395
 
#ifdef _HANDLE_ENLIST_IN_DTC_
396
 
                                        hmodule = DtcProc("SetMsdtclog", &proc);
397
 
                                        if (proc)
398
 
                                                (*proc)(IsDlgButtonChecked(hdlg, DRV_DTCLOG));
399
 
                                        if (hmodule)
400
 
                                                FreeLibrary(hmodule);
401
 
#endif /* _HANDLE_ENLIST_IN_DTC_ */
402
 
 
403
 
                                case IDCANCEL:
404
 
                                        EndDialog(hdlg, GET_WM_COMMAND_ID(wParam, lParam) == IDOK);
405
 
                                        return TRUE;
406
 
                        }
407
 
        }
408
 
 
409
 
        return FALSE;
410
 
}
411
 
 
412
 
LRESULT                 CALLBACK
413
 
ds_options1Proc(HWND hdlg,
414
 
                                   UINT wMsg,
415
 
                                   WPARAM wParam,
416
 
                                   LPARAM lParam)
417
 
{
418
 
        ConnInfo   *ci;
419
 
        char    strbuf[128];
420
 
 
421
 
        switch (wMsg)
422
 
        {
423
 
                case WM_INITDIALOG:
424
 
                        SetWindowLongPtr(hdlg, DWLP_USER, lParam);              /* save for OK etc */
425
 
                        ci = (ConnInfo *) lParam;
426
 
                        if (ci && ci->dsn && ci->dsn[0])
427
 
                        {
428
 
                                DWORD   cmd;
429
 
                                char    fbuf[64];
430
 
 
431
 
                                cmd = LoadString(s_hModule,
432
 
                                                IDS_ADVANCE_OPTION_DSN1,
433
 
                                                fbuf,
434
 
                                                sizeof(fbuf));
435
 
                                if (cmd <= 0)
436
 
                                        strcpy(fbuf, "Advanced Options (%s) 1/2");
437
 
                                sprintf(strbuf, fbuf, ci->dsn);
438
 
                                SetWindowText(hdlg, strbuf);
439
 
                        }
440
 
                        else
441
 
                        {
442
 
                                LoadString(s_hModule, IDS_ADVANCE_OPTION_CON1, strbuf, sizeof(strbuf)); 
443
 
                                SetWindowText(hdlg, strbuf);
444
 
                                ShowWindow(GetDlgItem(hdlg, IDAPPLY), SW_HIDE);
445
 
                        }
446
 
                        driver_optionsDraw(hdlg, ci, 1, FALSE);
447
 
                        break;
448
 
 
449
 
                case WM_COMMAND:
450
 
                        ci = (ConnInfo *) GetWindowLongPtr(hdlg, DWLP_USER);
451
 
                        switch (GET_WM_COMMAND_ID(wParam, lParam))
452
 
                        {
453
 
                                case IDOK:
454
 
                                        driver_options_update(hdlg, ci, NULL);
455
 
 
456
 
                                case IDCANCEL:
457
 
                                        EndDialog(hdlg, GET_WM_COMMAND_ID(wParam, lParam) == IDOK);
458
 
                                        return TRUE;
459
 
 
460
 
                                case IDAPPLY:
461
 
                                        driver_options_update(hdlg, ci, NULL);
462
 
                                        SendMessage(GetWindow(hdlg, GW_OWNER), WM_COMMAND, wParam, lParam);
463
 
                                        break;
464
 
 
465
 
                                case IDDEFAULTS:
466
 
                                        driver_optionsDraw(hdlg, ci, 0, FALSE);
467
 
                                        break;
468
 
 
469
 
                                case IDNEXTPAGE:
470
 
                                        driver_options_update(hdlg, ci, NULL);
471
 
 
472
 
                                        EndDialog(hdlg, FALSE);
473
 
                                        DialogBoxParam(s_hModule,
474
 
                                                MAKEINTRESOURCE(DLG_OPTIONS_DS),
475
 
                                                        hdlg, ds_options2Proc, (LPARAM)
476
 
ci);
477
 
                                        break;
478
 
                        }
479
 
        }
480
 
 
481
 
        return FALSE;
482
 
}
483
 
 
484
 
 
485
 
LRESULT                 CALLBACK
486
 
ds_options2Proc(HWND hdlg,
487
 
                           UINT wMsg,
488
 
                           WPARAM wParam,
489
 
                           LPARAM lParam)
490
 
{
491
 
        ConnInfo   *ci;
492
 
        char            buf[128];
493
 
        DWORD           cmd;
494
 
        BOOL            enable;
495
 
 
496
 
        switch (wMsg)
497
 
        {
498
 
                case WM_INITDIALOG:
499
 
                        ci = (ConnInfo *) lParam;
500
 
                        SetWindowLongPtr(hdlg, DWLP_USER, lParam);              /* save for OK */
501
 
 
502
 
                        /* Change window caption */
503
 
                        if (ci && ci->dsn && ci->dsn[0])
504
 
                        {
505
 
                                char    fbuf[64];
506
 
 
507
 
                                cmd = LoadString(s_hModule,
508
 
                                                IDS_ADVANCE_OPTION_DSN2,
509
 
                                                fbuf,
510
 
                                                sizeof(fbuf));
511
 
                                if (cmd <= 0)
512
 
                                        strcpy(fbuf, "Advanced Options (%s) 2/2");
513
 
                                sprintf(buf, fbuf, ci->dsn);
514
 
                                SetWindowText(hdlg, buf);
515
 
                        }
516
 
                        else
517
 
                        {
518
 
                                LoadString(s_hModule, IDS_ADVANCE_OPTION_CON2, buf, sizeof(buf)); 
519
 
                                SetWindowText(hdlg, buf);
520
 
                                ShowWindow(GetDlgItem(hdlg, IDAPPLY), SW_HIDE);                         }
521
 
 
522
 
                        /* Readonly */
523
 
                        CheckDlgButton(hdlg, DS_READONLY, atoi(ci->onlyread));
524
 
 
525
 
                        /* Protocol */
526
 
                        enable = (ci->sslmode[0] == SSLLBYTE_DISABLE || ci->username[0] == '\0');
527
 
                        EnableWindow(GetDlgItem(hdlg, DS_PG62), enable);
528
 
                        EnableWindow(GetDlgItem(hdlg, DS_PG63), enable);
529
 
                        EnableWindow(GetDlgItem(hdlg, DS_PG64), enable);
530
 
                        EnableWindow(GetDlgItem(hdlg, DS_PG74), enable);
531
 
                        if (PROTOCOL_62(ci))
532
 
                                CheckDlgButton(hdlg, DS_PG62, 1);
533
 
                        else if (PROTOCOL_63(ci))
534
 
                                CheckDlgButton(hdlg, DS_PG63, 1);
535
 
                        else if (PROTOCOL_64(ci))
536
 
                                CheckDlgButton(hdlg, DS_PG64, 1);
537
 
                        else
538
 
                                /* latest */
539
 
                                CheckDlgButton(hdlg, DS_PG74, 1);
540
 
 
541
 
                        /* How to issue Rollback */
542
 
                        switch (ci->rollback_on_error)
543
 
                        {
544
 
                                case 0:
545
 
                                        CheckDlgButton(hdlg, DS_NO_ROLLBACK, 1);
546
 
                                        break;
547
 
                                case 1:
548
 
                                        CheckDlgButton(hdlg, DS_TRANSACTION_ROLLBACK, 1);
549
 
                                        break;
550
 
                                case 2:
551
 
                                        CheckDlgButton(hdlg, DS_STATEMENT_ROLLBACK, 1);
552
 
                                        break;
553
 
                        }
554
 
 
555
 
                        /* Int8 As */
556
 
                        switch (ci->int8_as)
557
 
                        {
558
 
                                case SQL_BIGINT:
559
 
                                        CheckDlgButton(hdlg, DS_INT8_AS_BIGINT, 1);
560
 
                                        break;
561
 
                                case SQL_NUMERIC:
562
 
                                        CheckDlgButton(hdlg, DS_INT8_AS_NUMERIC, 1);
563
 
                                        break;
564
 
                                case SQL_VARCHAR:
565
 
                                        CheckDlgButton(hdlg, DS_INT8_AS_VARCHAR, 1);
566
 
                                        break;
567
 
                                case SQL_DOUBLE:
568
 
                                        CheckDlgButton(hdlg, DS_INT8_AS_DOUBLE, 1);
569
 
                                        break;
570
 
                                case SQL_INTEGER:
571
 
                                        CheckDlgButton(hdlg, DS_INT8_AS_INT4, 1);
572
 
                                        break;
573
 
                                default:
574
 
                                        CheckDlgButton(hdlg, DS_INT8_AS_DEFAULT, 1);
575
 
                        }
576
 
                        sprintf(buf, "0x%x", getExtraOptions(ci));
577
 
                        SetDlgItemText(hdlg, DS_EXTRA_OPTIONS, buf);
578
 
 
579
 
                        CheckDlgButton(hdlg, DS_SHOWOIDCOLUMN, atoi(ci->show_oid_column));
580
 
                        CheckDlgButton(hdlg, DS_FAKEOIDINDEX, atoi(ci->fake_oid_index));
581
 
                        CheckDlgButton(hdlg, DS_ROWVERSIONING, atoi(ci->row_versioning));
582
 
                        CheckDlgButton(hdlg, DS_SHOWSYSTEMTABLES, atoi(ci->show_system_tables));
583
 
                        CheckDlgButton(hdlg, DS_DISALLOWPREMATURE, ci->disallow_premature);
584
 
                        CheckDlgButton(hdlg, DS_LFCONVERSION, ci->lf_conversion);
585
 
                        CheckDlgButton(hdlg, DS_TRUEISMINUS1, ci->true_is_minus1);
586
 
                        CheckDlgButton(hdlg, DS_UPDATABLECURSORS, ci->allow_keyset);
587
 
                        CheckDlgButton(hdlg, DS_SERVERSIDEPREPARE, ci->use_server_side_prepare);
588
 
                        CheckDlgButton(hdlg, DS_BYTEAASLONGVARBINARY, ci->bytea_as_longvarbinary);
589
 
                        /*CheckDlgButton(hdlg, DS_LOWERCASEIDENTIFIER, ci->lower_case_identifier);*/
590
 
                        CheckDlgButton(hdlg, DS_GSSAUTHUSEGSSAPI, ci->gssauth_use_gssapi);
591
 
 
592
 
#if     defined(NOT_USE_LIBPQ) && !defined(USE_SSPI) && !defined(USE_GSS)
593
 
                        EnableWindow(GetDlgItem(hdlg, DS_GSSAUTHUSEGSSAPI), FALSE);
594
 
#endif
595
 
                        EnableWindow(GetDlgItem(hdlg, DS_FAKEOIDINDEX), atoi(ci->show_oid_column));
596
 
 
597
 
                        /* Datasource Connection Settings */
598
 
                        SetDlgItemText(hdlg, DS_CONNSETTINGS, ci->conn_settings);
599
 
                        break;
600
 
 
601
 
                case WM_COMMAND:
602
 
                        switch (cmd = GET_WM_COMMAND_ID(wParam, lParam))
603
 
                        {
604
 
                                case DS_SHOWOIDCOLUMN:
605
 
                                        mylog("WM_COMMAND: DS_SHOWOIDCOLUMN\n");
606
 
                                        EnableWindow(GetDlgItem(hdlg, DS_FAKEOIDINDEX), IsDlgButtonChecked(hdlg, DS_SHOWOIDCOLUMN));
607
 
                                        return TRUE;
608
 
 
609
 
                                case IDOK:
610
 
                                case IDAPPLY:
611
 
                                case IDPREVPAGE:
612
 
                                        ci = (ConnInfo *) GetWindowLongPtr(hdlg, DWLP_USER);
613
 
                                        mylog("IDOK: got ci = %p\n", ci);
614
 
 
615
 
                                        /* Readonly */
616
 
                                        sprintf(ci->onlyread, "%d", IsDlgButtonChecked(hdlg, DS_READONLY));
617
 
 
618
 
                                        /* Protocol */
619
 
                                        if (IsDlgButtonChecked(hdlg, DS_PG62))
620
 
                                                strcpy(ci->protocol, PG62);
621
 
                                        else if (IsDlgButtonChecked(hdlg, DS_PG63))
622
 
                                                strcpy(ci->protocol, PG63);
623
 
                                        else if (IsDlgButtonChecked(hdlg, DS_PG64))
624
 
                                                strcpy(ci->protocol, PG64);
625
 
                                        else
626
 
                                                /* latest */
627
 
                                                strcpy(ci->protocol, PG74);
628
 
 
629
 
                                        /* Issue rollback command on error */
630
 
                                        if (IsDlgButtonChecked(hdlg, DS_NO_ROLLBACK))
631
 
                                                ci->rollback_on_error = 0;
632
 
                                        else if (IsDlgButtonChecked(hdlg, DS_TRANSACTION_ROLLBACK))
633
 
                                                ci->rollback_on_error = 1;
634
 
                                        else if (IsDlgButtonChecked(hdlg, DS_STATEMENT_ROLLBACK))
635
 
                                                ci->rollback_on_error = 2;
636
 
                                        else
637
 
                                                /* legacy */
638
 
                                                ci->rollback_on_error = 1;
639
 
 
640
 
                                        /* Int8 As */
641
 
                                        if (IsDlgButtonChecked(hdlg, DS_INT8_AS_DEFAULT))
642
 
                                                ci->int8_as = 0;
643
 
                                        else if (IsDlgButtonChecked(hdlg, DS_INT8_AS_BIGINT))
644
 
                                                ci->int8_as = SQL_BIGINT;
645
 
                                        else if (IsDlgButtonChecked(hdlg, DS_INT8_AS_NUMERIC))
646
 
                                                ci->int8_as = SQL_NUMERIC;
647
 
                                        else if (IsDlgButtonChecked(hdlg, DS_INT8_AS_DOUBLE))
648
 
                                                ci->int8_as = SQL_DOUBLE;
649
 
                                        else if (IsDlgButtonChecked(hdlg, DS_INT8_AS_INT4))
650
 
                                                ci->int8_as = SQL_INTEGER;
651
 
                                        else
652
 
                                                ci->int8_as = SQL_VARCHAR;
653
 
 
654
 
                                        GetDlgItemText(hdlg, DS_EXTRA_OPTIONS, buf, sizeof(buf));
655
 
                                        setExtraOptions(ci, buf, NULL);
656
 
                                        sprintf(ci->show_system_tables, "%d", IsDlgButtonChecked(hdlg, DS_SHOWSYSTEMTABLES));
657
 
 
658
 
                                        sprintf(ci->row_versioning, "%d", IsDlgButtonChecked(hdlg, DS_ROWVERSIONING));
659
 
                                        ci->disallow_premature = IsDlgButtonChecked(hdlg, DS_DISALLOWPREMATURE);
660
 
                                        ci->lf_conversion = IsDlgButtonChecked(hdlg, DS_LFCONVERSION);
661
 
                                        ci->true_is_minus1 = IsDlgButtonChecked(hdlg, DS_TRUEISMINUS1);
662
 
                                        ci->allow_keyset = IsDlgButtonChecked(hdlg, DS_UPDATABLECURSORS);
663
 
                                        ci->use_server_side_prepare = IsDlgButtonChecked(hdlg, DS_SERVERSIDEPREPARE);
664
 
                                        ci->bytea_as_longvarbinary = IsDlgButtonChecked(hdlg, DS_BYTEAASLONGVARBINARY);
665
 
                                        /*ci->lower_case_identifier = IsDlgButtonChecked(hdlg, DS_LOWERCASEIDENTIFIER);*/
666
 
                                        ci->gssauth_use_gssapi = IsDlgButtonChecked(hdlg, DS_GSSAUTHUSEGSSAPI);
667
 
 
668
 
                                        /* OID Options */
669
 
                                        sprintf(ci->fake_oid_index, "%d", IsDlgButtonChecked(hdlg, DS_FAKEOIDINDEX));
670
 
                                        sprintf(ci->show_oid_column, "%d", IsDlgButtonChecked(hdlg, DS_SHOWOIDCOLUMN));
671
 
 
672
 
                                        /* Datasource Connection Settings */
673
 
                                        GetDlgItemText(hdlg, DS_CONNSETTINGS, ci->conn_settings, sizeof(ci->conn_settings));
674
 
                                        if (IDAPPLY == cmd)
675
 
                                        {
676
 
                                                SendMessage(GetWindow(hdlg, GW_OWNER), WM_COMMAND, wParam, lParam);
677
 
                                                break;
678
 
                                        }
679
 
 
680
 
                                        EndDialog(hdlg, cmd == IDOK);
681
 
                                        if (IDOK == cmd) 
682
 
                                                return TRUE;
683
 
                                        DialogBoxParam(s_hModule,
684
 
                                                MAKEINTRESOURCE(DLG_OPTIONS_DRV),
685
 
                                                hdlg, ds_options1Proc, (LPARAM) ci);
686
 
                                        break;
687
 
 
688
 
                                case IDCANCEL:
689
 
                                        EndDialog(hdlg, GET_WM_COMMAND_ID(wParam, lParam) == IDOK);
690
 
                                        return TRUE;
691
 
                        }
692
 
        }
693
 
 
694
 
        return FALSE;
695
 
}
696
 
 
697
 
typedef SQLRETURN (SQL_API *SQLAPIPROC)();
698
 
static int
699
 
makeDriversList(HWND lwnd, const ConnInfo *ci)
700
 
{
701
 
        HMODULE hmodule;
702
 
        SQLHENV henv;
703
 
        int     lcount = 0;
704
 
        LRESULT iidx;
705
 
        char    drvname[64], drvatt[128];
706
 
        SQLUSMALLINT    direction = SQL_FETCH_FIRST;
707
 
        SQLSMALLINT     drvncount, drvacount;
708
 
        SQLRETURN       ret;
709
 
        SQLAPIPROC      addr;
710
 
 
711
 
        hmodule = GetModuleHandle("ODBC32");
712
 
        if (!hmodule)   return lcount;
713
 
        addr = (SQLAPIPROC) GetProcAddress(hmodule, "SQLAllocEnv");
714
 
        if (!addr)      return lcount;
715
 
        ret = (*addr)(&henv);
716
 
        if (SQL_SUCCESS != ret) return lcount;
717
 
        do
718
 
        {
719
 
                ret = SQLDrivers(henv, direction,
720
 
                        drvname, sizeof(drvname), &drvncount, 
721
 
                        drvatt, sizeof(drvatt), &drvacount); 
722
 
                if (SQL_SUCCESS != ret && SQL_SUCCESS_WITH_INFO != ret)
723
 
                        break;
724
 
                if (strnicmp(drvname, "postgresql", 10) == 0)
725
 
                {
726
 
                        iidx = SendMessage(lwnd, LB_ADDSTRING, 0, (LPARAM) drvname);
727
 
                        if (LB_ERR != iidx && stricmp(drvname, ci->drivername) == 0)
728
 
{
729
 
                                SendMessage(lwnd, LB_SETCURSEL, (WPARAM) iidx, (LPARAM) 0);
730
 
}
731
 
                        lcount++;
732
 
                }
733
 
                direction = SQL_FETCH_NEXT;
734
 
        } while (1);
735
 
        addr = (SQLAPIPROC) GetProcAddress(hmodule, "SQLFreeEnv");
736
 
        if (addr)
737
 
                (*addr)(henv);
738
 
 
739
 
        return lcount;
740
 
}
741
 
 
742
 
LRESULT         CALLBACK
743
 
manage_dsnProc(HWND hdlg, UINT wMsg,
744
 
                WPARAM wParam, LPARAM lParam)
745
 
{
746
 
        LPSETUPDLG      lpsetupdlg;
747
 
        ConnInfo        *ci;
748
 
        HWND            lwnd;
749
 
        LRESULT         sidx;
750
 
        char            drvname[64];
751
 
 
752
 
        switch (wMsg)
753
 
        {
754
 
                case WM_INITDIALOG:
755
 
                        SetWindowLongPtr(hdlg, DWLP_USER, lParam);
756
 
                        lpsetupdlg = (LPSETUPDLG) lParam;
757
 
                        ci = &lpsetupdlg->ci;
758
 
                        lwnd = GetDlgItem(hdlg, IDC_DRIVER_LIST);
759
 
                        makeDriversList(lwnd, ci);
760
 
                        break;
761
 
 
762
 
                case WM_COMMAND:
763
 
                        switch (GET_WM_COMMAND_ID(wParam, lParam))
764
 
                        {
765
 
                                case IDOK:
766
 
                                        lpsetupdlg = (LPSETUPDLG) GetWindowLongPtr(hdlg, DWLP_USER);
767
 
                                        lwnd = GetDlgItem(hdlg, IDC_DRIVER_LIST);
768
 
                                        sidx = SendMessage(lwnd, LB_GETCURSEL,
769
 
                                                (WPARAM) 0, (LPARAM) 0);
770
 
                                        if (LB_ERR == sidx)
771
 
                                                return FALSE;
772
 
                                        sidx = SendMessage(lwnd, LB_GETTEXT,
773
 
                                                (WPARAM) sidx, (LPARAM) drvname);
774
 
                                        if (LB_ERR == sidx)
775
 
                                                return FALSE;
776
 
                                        ChangeDriverName(hdlg, lpsetupdlg, drvname);
777
 
 
778
 
                                case IDCANCEL:
779
 
                                        EndDialog(hdlg, GET_WM_COMMAND_ID(wParam, lParam) == IDOK);
780
 
                                        return TRUE;
781
 
                        }
782
 
        }
783
 
 
784
 
        return FALSE;
785
 
}
786
 
 
787
 
#endif /* WIN32 */
 
1
#ifdef  WIN32
 
2
/*-------
 
3
 * Module:                      dlg_wingui.c
 
4
 *
 
5
 * Description:         This module contains any specific code for handling
 
6
 *                                      dialog boxes such as driver/datasource options.  Both the
 
7
 *                                      ConfigDSN() and the SQLDriverConnect() functions use
 
8
 *                                      functions in this module.  If you were to add a new option
 
9
 *                                      to any dialog box, you would most likely only have to change
 
10
 *                                      things in here rather than in 2 separate places as before.
 
11
 *
 
12
 * Classes:                     none
 
13
 *
 
14
 * API functions:       none
 
15
 *
 
16
 * Comments:            See "readme.txt" for copyright and license information.
 
17
 *-------
 
18
 */
 
19
/* Multibyte support    Eiji Tokuya 2001-03-15 */
 
20
 
 
21
#include "dlg_specific.h"
 
22
#include "win_setup.h"
 
23
 
 
24
#include "convert.h"
 
25
#include "loadlib.h"
 
26
 
 
27
#include "multibyte.h"
 
28
#include "pgapifunc.h"
 
29
 
 
30
extern GLOBAL_VALUES globals;
 
31
 
 
32
extern HINSTANCE NEAR s_hModule;
 
33
static int      driver_optionsDraw(HWND, const ConnInfo *, int src, BOOL enable);
 
34
static int      driver_options_update(HWND hdlg, ConnInfo *ci, const char *);
 
35
 
 
36
static struct {
 
37
        int     ids;
 
38
        const char * const      modestr;
 
39
} modetab[] = {
 
40
                  {IDS_SSLREQUEST_DISABLE, SSLMODE_DISABLE}
 
41
                , {IDS_SSLREQUEST_ALLOW, SSLMODE_ALLOW}
 
42
                , {IDS_SSLREQUEST_PREFER, SSLMODE_PREFER}
 
43
                , {IDS_SSLREQUEST_REQUIRE, SSLMODE_REQUIRE}
 
44
                , {IDS_SSLREQUEST_VERIFY_CA, SSLMODE_VERIFY_CA}
 
45
                , {IDS_SSLREQUEST_VERIFY_FULL, SSLMODE_VERIFY_FULL}
 
46
        };
 
47
static int      dspcount_bylevel[] = {1, 4, 6};
 
48
 
 
49
void
 
50
SetDlgStuff(HWND hdlg, const ConnInfo *ci)
 
51
{
 
52
        char    buff[MEDIUM_REGISTRY_LEN + 1];
 
53
        BOOL    libpq_exist = FALSE;
 
54
        int     i, dsplevel, selidx, dspcount;
 
55
 
 
56
        /*
 
57
         * If driver attribute NOT present, then set the datasource name and
 
58
         * description
 
59
         */
 
60
        SetDlgItemText(hdlg, IDC_DSNAME, ci->dsn);
 
61
        SetDlgItemText(hdlg, IDC_DESC, ci->desc);
 
62
 
 
63
        SetDlgItemText(hdlg, IDC_DATABASE, ci->database);
 
64
        SetDlgItemText(hdlg, IDC_SERVER, ci->server);
 
65
        SetDlgItemText(hdlg, IDC_USER, ci->username);
 
66
        SetDlgItemText(hdlg, IDC_PASSWORD, ci->password);
 
67
        SetDlgItemText(hdlg, IDC_PORT, ci->port);
 
68
 
 
69
        dsplevel = 0;
 
70
        libpq_exist = SSLLIB_check();
 
71
mylog("libpq_exist=%d\n", libpq_exist);
 
72
        if (libpq_exist)
 
73
        {
 
74
                ShowWindow(GetDlgItem(hdlg, IDC_NOTICE_USER), SW_HIDE);
 
75
                dsplevel = 2;
 
76
        }
 
77
        else
 
78
        {
 
79
mylog("SendMessage CTL_COLOR\n");
 
80
                SendMessage(GetDlgItem(hdlg, IDC_NOTICE_USER), WM_CTLCOLOR, 0, 0);
 
81
#ifdef  USE_SSPI
 
82
                dsplevel = 1;
 
83
#endif /* USE_SSPI */
 
84
        }
 
85
 
 
86
        selidx = -1;
 
87
        for (i = 0; i < sizeof(modetab) / sizeof(modetab[0]); i++)
 
88
        {
 
89
                if (!stricmp(ci->sslmode, modetab[i].modestr))
 
90
                {
 
91
                        selidx = i;
 
92
                        break;
 
93
                }
 
94
        }
 
95
        for (i = dsplevel; i < sizeof(dspcount_bylevel) / sizeof(int); i++)
 
96
        {
 
97
                if (selidx < dspcount_bylevel[i])
 
98
                        break;
 
99
                dsplevel++;
 
100
        }
 
101
        
 
102
        dspcount = dspcount_bylevel[dsplevel];
 
103
        for (i = 0; i < dspcount; i++)
 
104
        {
 
105
                LoadString(GetWindowInstance(hdlg), modetab[i].ids, buff, MEDIUM_REGISTRY_LEN);
 
106
                SendDlgItemMessage(hdlg, IDC_SSLMODE, CB_ADDSTRING, 0, (WPARAM) buff);
 
107
        }
 
108
 
 
109
        SendDlgItemMessage(hdlg, IDC_SSLMODE, CB_SETCURSEL, selidx, (WPARAM) 0);
 
110
}
 
111
 
 
112
 
 
113
void
 
114
GetDlgStuff(HWND hdlg, ConnInfo *ci)
 
115
{
 
116
        int     sslposition;
 
117
 
 
118
        GetDlgItemText(hdlg, IDC_DESC, ci->desc, sizeof(ci->desc));
 
119
 
 
120
        GetDlgItemText(hdlg, IDC_DATABASE, ci->database, sizeof(ci->database));
 
121
        GetDlgItemText(hdlg, IDC_SERVER, ci->server, sizeof(ci->server));
 
122
        GetDlgItemText(hdlg, IDC_USER, ci->username, sizeof(ci->username));
 
123
        GetDlgItemText(hdlg, IDC_PASSWORD, ci->password, sizeof(ci->password));
 
124
        GetDlgItemText(hdlg, IDC_PORT, ci->port, sizeof(ci->port));
 
125
        sslposition = (int)(DWORD)SendMessage(GetDlgItem(hdlg, IDC_SSLMODE), CB_GETCURSEL, 0L, 0L);
 
126
        strncpy_null(ci->sslmode, modetab[sslposition].modestr, sizeof(ci->sslmode));
 
127
}
 
128
 
 
129
 
 
130
static int
 
131
driver_optionsDraw(HWND hdlg, const ConnInfo *ci, int src, BOOL enable)
 
132
{
 
133
        const GLOBAL_VALUES *comval;
 
134
        static BOOL defset = FALSE;
 
135
        static GLOBAL_VALUES defval;
 
136
 
 
137
        switch (src)
 
138
        {
 
139
                case 0:                 /* driver common */
 
140
                        comval = &globals;
 
141
                        break;
 
142
                case 1:                 /* dsn specific */
 
143
                        comval = &(ci->drivers);
 
144
                        break;
 
145
                case 2:                 /* default */
 
146
                        if (!defset)
 
147
                        {
 
148
                                defval.commlog = DEFAULT_COMMLOG;
 
149
                                defval.disable_optimizer = DEFAULT_OPTIMIZER;
 
150
                                defval.ksqo = DEFAULT_KSQO;
 
151
                                defval.unique_index = DEFAULT_UNIQUEINDEX;
 
152
                                defval.onlyread = DEFAULT_READONLY;
 
153
                                defval.use_declarefetch = DEFAULT_USEDECLAREFETCH;
 
154
 
 
155
                                defval.parse = DEFAULT_PARSE;
 
156
                                defval.cancel_as_freestmt = DEFAULT_CANCELASFREESTMT;
 
157
                                defval.debug = DEFAULT_DEBUG;
 
158
 
 
159
                                /* Unknown Sizes */
 
160
                                defval.unknown_sizes = DEFAULT_UNKNOWNSIZES;
 
161
                                defval.text_as_longvarchar = DEFAULT_TEXTASLONGVARCHAR;
 
162
                                defval.unknowns_as_longvarchar = DEFAULT_UNKNOWNSASLONGVARCHAR;
 
163
                                defval.bools_as_char = DEFAULT_BOOLSASCHAR;
 
164
                        }
 
165
                        defset = TRUE;
 
166
                        comval = &defval;
 
167
                        break;
 
168
        }
 
169
 
 
170
        ShowWindow(GetDlgItem(hdlg, DRV_MSG_LABEL2), enable ? SW_SHOW : SW_HIDE);
 
171
        CheckDlgButton(hdlg, DRV_COMMLOG, comval->commlog);
 
172
#ifndef Q_LOG
 
173
        EnableWindow(GetDlgItem(hdlg, DRV_COMMLOG), FALSE);
 
174
#endif /* Q_LOG */
 
175
        CheckDlgButton(hdlg, DRV_OPTIMIZER, comval->disable_optimizer);
 
176
        CheckDlgButton(hdlg, DRV_KSQO, comval->ksqo);
 
177
        CheckDlgButton(hdlg, DRV_UNIQUEINDEX, comval->unique_index);
 
178
        /* EnableWindow(GetDlgItem(hdlg, DRV_UNIQUEINDEX), enable); */
 
179
        CheckDlgButton(hdlg, DRV_READONLY, comval->onlyread);
 
180
        EnableWindow(GetDlgItem(hdlg, DRV_READONLY), enable);
 
181
        CheckDlgButton(hdlg, DRV_USEDECLAREFETCH, comval->use_declarefetch);
 
182
 
 
183
        /* Unknown Sizes clear */
 
184
        CheckDlgButton(hdlg, DRV_UNKNOWN_DONTKNOW, 0);
 
185
        CheckDlgButton(hdlg, DRV_UNKNOWN_LONGEST, 0);
 
186
        CheckDlgButton(hdlg, DRV_UNKNOWN_MAX, 0);
 
187
        /* Unknown (Default) Data Type sizes */
 
188
        switch (comval->unknown_sizes)
 
189
        {
 
190
                case UNKNOWNS_AS_DONTKNOW:
 
191
                        CheckDlgButton(hdlg, DRV_UNKNOWN_DONTKNOW, 1);
 
192
                        break;
 
193
                case UNKNOWNS_AS_LONGEST:
 
194
                        CheckDlgButton(hdlg, DRV_UNKNOWN_LONGEST, 1);
 
195
                        break;
 
196
                case UNKNOWNS_AS_MAX:
 
197
                default:
 
198
                        CheckDlgButton(hdlg, DRV_UNKNOWN_MAX, 1);
 
199
                        break;
 
200
        }
 
201
 
 
202
        CheckDlgButton(hdlg, DRV_TEXT_LONGVARCHAR, comval->text_as_longvarchar);
 
203
        CheckDlgButton(hdlg, DRV_UNKNOWNS_LONGVARCHAR, comval->unknowns_as_longvarchar);
 
204
        CheckDlgButton(hdlg, DRV_BOOLS_CHAR, comval->bools_as_char);
 
205
        CheckDlgButton(hdlg, DRV_PARSE, comval->parse);
 
206
        CheckDlgButton(hdlg, DRV_CANCELASFREESTMT, comval->cancel_as_freestmt);
 
207
        CheckDlgButton(hdlg, DRV_DEBUG, comval->debug);
 
208
#ifndef MY_LOG
 
209
        EnableWindow(GetDlgItem(hdlg, DRV_DEBUG), FALSE);
 
210
#endif /* MY_LOG */
 
211
        SetDlgItemInt(hdlg, DRV_CACHE_SIZE, comval->fetch_max, FALSE);
 
212
        SetDlgItemInt(hdlg, DRV_VARCHAR_SIZE, comval->max_varchar_size, FALSE);
 
213
        SetDlgItemInt(hdlg, DRV_LONGVARCHAR_SIZE, comval->max_longvarchar_size, TRUE);
 
214
        SetDlgItemText(hdlg, DRV_EXTRASYSTABLEPREFIXES, comval->extra_systable_prefixes);
 
215
 
 
216
        /* Driver Connection Settings */
 
217
        SetDlgItemText(hdlg, DRV_CONNSETTINGS, comval->conn_settings);
 
218
        EnableWindow(GetDlgItem(hdlg, DRV_CONNSETTINGS), enable);
 
219
        ShowWindow(GetDlgItem(hdlg, IDPREVPAGE), enable ? SW_HIDE : SW_SHOW);
 
220
        ShowWindow(GetDlgItem(hdlg, IDNEXTPAGE), enable ? SW_HIDE : SW_SHOW);
 
221
        return 0;
 
222
}
 
223
 
 
224
static int
 
225
driver_options_update(HWND hdlg, ConnInfo *ci, const char *updateDriver)
 
226
{
 
227
        GLOBAL_VALUES *comval;
 
228
 
 
229
        if (ci)
 
230
                comval = &(ci->drivers);
 
231
        else
 
232
                comval = &globals;
 
233
        comval->commlog = IsDlgButtonChecked(hdlg, DRV_COMMLOG);
 
234
        comval->disable_optimizer = IsDlgButtonChecked(hdlg, DRV_OPTIMIZER);
 
235
        comval->ksqo = IsDlgButtonChecked(hdlg, DRV_KSQO);
 
236
        comval->unique_index = IsDlgButtonChecked(hdlg, DRV_UNIQUEINDEX);
 
237
        if (!ci)
 
238
        {
 
239
                comval->onlyread = IsDlgButtonChecked(hdlg, DRV_READONLY);
 
240
        }
 
241
        comval->use_declarefetch = IsDlgButtonChecked(hdlg, DRV_USEDECLAREFETCH);
 
242
 
 
243
        /* Unknown (Default) Data Type sizes */
 
244
        if (IsDlgButtonChecked(hdlg, DRV_UNKNOWN_MAX))
 
245
                comval->unknown_sizes = UNKNOWNS_AS_MAX;
 
246
        else if (IsDlgButtonChecked(hdlg, DRV_UNKNOWN_DONTKNOW))
 
247
                comval->unknown_sizes = UNKNOWNS_AS_DONTKNOW;
 
248
        else if (IsDlgButtonChecked(hdlg, DRV_UNKNOWN_LONGEST))
 
249
                comval->unknown_sizes = UNKNOWNS_AS_LONGEST;
 
250
        else
 
251
                comval->unknown_sizes = UNKNOWNS_AS_MAX;
 
252
 
 
253
        comval->text_as_longvarchar = IsDlgButtonChecked(hdlg, DRV_TEXT_LONGVARCHAR);
 
254
        comval->unknowns_as_longvarchar = IsDlgButtonChecked(hdlg, DRV_UNKNOWNS_LONGVARCHAR);
 
255
        comval->bools_as_char = IsDlgButtonChecked(hdlg, DRV_BOOLS_CHAR);
 
256
 
 
257
        comval->parse = IsDlgButtonChecked(hdlg, DRV_PARSE);
 
258
 
 
259
        comval->cancel_as_freestmt = IsDlgButtonChecked(hdlg, DRV_CANCELASFREESTMT);
 
260
        comval->debug = IsDlgButtonChecked(hdlg, DRV_DEBUG);
 
261
 
 
262
        comval->fetch_max = GetDlgItemInt(hdlg, DRV_CACHE_SIZE, NULL, FALSE);
 
263
        comval->max_varchar_size = GetDlgItemInt(hdlg, DRV_VARCHAR_SIZE, NULL, FALSE);
 
264
        comval->max_longvarchar_size = GetDlgItemInt(hdlg, DRV_LONGVARCHAR_SIZE, NULL, TRUE);           /* allows for
 
265
                                                                                                                                                                                                 * SQL_NO_TOTAL */
 
266
 
 
267
        GetDlgItemText(hdlg, DRV_EXTRASYSTABLEPREFIXES, comval->extra_systable_prefixes, sizeof(comval->extra_systable_prefixes));
 
268
 
 
269
        /* Driver Connection Settings */
 
270
        if (!ci)
 
271
                GetDlgItemText(hdlg, DRV_CONNSETTINGS, comval->conn_settings, sizeof(comval->conn_settings));
 
272
 
 
273
        if (updateDriver)
 
274
        {
 
275
                if (writeDriverCommoninfo(ODBCINST_INI, updateDriver, comval) < 0)
 
276
                        MessageBox(hdlg, "impossible to update the values, sorry", "Update Error", MB_ICONEXCLAMATION | MB_OK);
 
277
;
 
278
        }
 
279
 
 
280
        /* fall through */
 
281
        return 0;
 
282
}
 
283
 
 
284
LRESULT         CALLBACK
 
285
driver_optionsProc(HWND hdlg,
 
286
                                   UINT wMsg,
 
287
                                   WPARAM wParam,
 
288
                                   LPARAM lParam)
 
289
{
 
290
        ConnInfo   *ci;
 
291
        char    strbuf[128];
 
292
 
 
293
        switch (wMsg)
 
294
        {
 
295
                case WM_INITDIALOG:
 
296
                        SetWindowLongPtr(hdlg, DWLP_USER, lParam);              /* save for OK etc */
 
297
                        ci = (ConnInfo *) lParam;
 
298
                        LoadString(s_hModule, IDS_ADVANCE_OPTION_DEF, strbuf, sizeof(strbuf)); 
 
299
                        SetWindowText(hdlg, strbuf);
 
300
                        LoadString(s_hModule, IDS_ADVANCE_SAVE, strbuf, sizeof(strbuf)); 
 
301
                        SetWindowText(GetDlgItem(hdlg, IDOK), strbuf);
 
302
                        ShowWindow(GetDlgItem(hdlg, IDAPPLY), SW_HIDE);
 
303
                        driver_optionsDraw(hdlg, ci, 0, TRUE);
 
304
                        break;
 
305
 
 
306
                case WM_COMMAND:
 
307
                        switch (GET_WM_COMMAND_ID(wParam, lParam))
 
308
                        {
 
309
                                case IDOK:
 
310
                                        ci = (ConnInfo *) GetWindowLongPtr(hdlg, DWLP_USER);
 
311
                                        driver_options_update(hdlg, NULL,
 
312
                                                ci ? ci->drivername : NULL);
 
313
 
 
314
                                case IDCANCEL:
 
315
                                        EndDialog(hdlg, GET_WM_COMMAND_ID(wParam, lParam) == IDOK);
 
316
                                        return TRUE;
 
317
 
 
318
                                case IDDEFAULTS:
 
319
                                        driver_optionsDraw(hdlg, NULL, 2, TRUE);
 
320
                                        break;
 
321
                        }
 
322
        }
 
323
 
 
324
        return FALSE;
 
325
}
 
326
 
 
327
#ifdef _HANDLE_ENLIST_IN_DTC_
 
328
static
 
329
HMODULE DtcProc(const char *procname, FARPROC *proc)
 
330
{
 
331
        HMODULE hmodule;
 
332
 
 
333
        *proc = NULL;
 
334
        if (hmodule = LoadLibrary(GetXaLibPath()), NULL != hmodule)
 
335
        {
 
336
mylog("GetProcAddres for %s\n", procname);
 
337
                *proc = GetProcAddress(hmodule, procname);
 
338
        }
 
339
 
 
340
        return hmodule;
 
341
}
 
342
#endif /* _HANDLE_ENLIST_IN_DTC_ */
 
343
 
 
344
LRESULT                 CALLBACK
 
345
global_optionsProc(HWND hdlg,
 
346
                                   UINT wMsg,
 
347
                                   WPARAM wParam,
 
348
                                   LPARAM lParam)
 
349
{
 
350
#ifdef _HANDLE_ENLIST_IN_DTC_
 
351
        HMODULE hmodule;
 
352
        FARPROC proc;
 
353
#endif /* _HANDLE_ENLIST_IN_DTC_ */
 
354
        char logdir[PATH_MAX];
 
355
 
 
356
        switch (wMsg)
 
357
        {
 
358
                case WM_INITDIALOG:
 
359
                        CheckDlgButton(hdlg, DRV_COMMLOG, globals.commlog);
 
360
#ifndef Q_LOG
 
361
                        EnableWindow(GetDlgItem(hdlg, DRV_COMMLOG), FALSE);
 
362
#endif /* Q_LOG */
 
363
                        CheckDlgButton(hdlg, DRV_DEBUG, globals.debug);
 
364
#ifndef MY_LOG
 
365
                        EnableWindow(GetDlgItem(hdlg, DRV_DEBUG), FALSE);
 
366
#endif /* MY_LOG */
 
367
                        getLogDir(logdir, sizeof(logdir));
 
368
                        SetDlgItemText(hdlg, DS_LOGDIR, logdir);
 
369
#ifdef _HANDLE_ENLIST_IN_DTC_
 
370
                        hmodule = DtcProc("GetMsdtclog", &proc);
 
371
                        if (proc)
 
372
                        {
 
373
                                INT_PTR res = (*proc)();
 
374
                                CheckDlgButton(hdlg, DRV_DTCLOG, 0 != res);
 
375
                        }
 
376
                        else
 
377
                                EnableWindow(GetDlgItem(hdlg, DRV_DTCLOG), FALSE);
 
378
                        if (hmodule)
 
379
                                FreeLibrary(hmodule);
 
380
#else
 
381
                        ShowWindow(GetDlgItem(hdlg, DRV_DTCLOG), SW_HIDE);
 
382
#endif /* _HANDLE_ENLIST_IN_DTC_ */
 
383
                        break;
 
384
 
 
385
                case WM_COMMAND:
 
386
                        switch (GET_WM_COMMAND_ID(wParam, lParam))
 
387
                        {
 
388
                                case IDOK:
 
389
                                        globals.commlog = IsDlgButtonChecked(hdlg, DRV_COMMLOG);
 
390
                                        globals.debug = IsDlgButtonChecked(hdlg, DRV_DEBUG);
 
391
                                        if (writeDriverCommoninfo(ODBCINST_INI, NULL, &globals) < 0)
 
392
                                                MessageBox(hdlg, "Sorry, impossible to update the values\nWrite permission seems to be needed", "Update Error", MB_ICONEXCLAMATION | MB_OK);
 
393
                                        GetDlgItemText(hdlg, DS_LOGDIR, logdir, sizeof(logdir));
 
394
                                        setLogDir(logdir[0] ? logdir : NULL);
 
395
#ifdef _HANDLE_ENLIST_IN_DTC_
 
396
                                        hmodule = DtcProc("SetMsdtclog", &proc);
 
397
                                        if (proc)
 
398
                                                (*proc)(IsDlgButtonChecked(hdlg, DRV_DTCLOG));
 
399
                                        if (hmodule)
 
400
                                                FreeLibrary(hmodule);
 
401
#endif /* _HANDLE_ENLIST_IN_DTC_ */
 
402
 
 
403
                                case IDCANCEL:
 
404
                                        EndDialog(hdlg, GET_WM_COMMAND_ID(wParam, lParam) == IDOK);
 
405
                                        return TRUE;
 
406
                        }
 
407
        }
 
408
 
 
409
        return FALSE;
 
410
}
 
411
 
 
412
LRESULT                 CALLBACK
 
413
ds_options1Proc(HWND hdlg,
 
414
                                   UINT wMsg,
 
415
                                   WPARAM wParam,
 
416
                                   LPARAM lParam)
 
417
{
 
418
        ConnInfo   *ci;
 
419
        char    strbuf[128];
 
420
 
 
421
        switch (wMsg)
 
422
        {
 
423
                case WM_INITDIALOG:
 
424
                        SetWindowLongPtr(hdlg, DWLP_USER, lParam);              /* save for OK etc */
 
425
                        ci = (ConnInfo *) lParam;
 
426
                        if (ci && ci->dsn && ci->dsn[0])
 
427
                        {
 
428
                                DWORD   cmd;
 
429
                                char    fbuf[64];
 
430
 
 
431
                                cmd = LoadString(s_hModule,
 
432
                                                IDS_ADVANCE_OPTION_DSN1,
 
433
                                                fbuf,
 
434
                                                sizeof(fbuf));
 
435
                                if (cmd <= 0)
 
436
                                        strcpy(fbuf, "Advanced Options (%s) 1/2");
 
437
                                sprintf(strbuf, fbuf, ci->dsn);
 
438
                                SetWindowText(hdlg, strbuf);
 
439
                        }
 
440
                        else
 
441
                        {
 
442
                                LoadString(s_hModule, IDS_ADVANCE_OPTION_CON1, strbuf, sizeof(strbuf)); 
 
443
                                SetWindowText(hdlg, strbuf);
 
444
                                ShowWindow(GetDlgItem(hdlg, IDAPPLY), SW_HIDE);
 
445
                        }
 
446
                        driver_optionsDraw(hdlg, ci, 1, FALSE);
 
447
                        break;
 
448
 
 
449
                case WM_COMMAND:
 
450
                        ci = (ConnInfo *) GetWindowLongPtr(hdlg, DWLP_USER);
 
451
                        switch (GET_WM_COMMAND_ID(wParam, lParam))
 
452
                        {
 
453
                                case IDOK:
 
454
                                        driver_options_update(hdlg, ci, NULL);
 
455
 
 
456
                                case IDCANCEL:
 
457
                                        EndDialog(hdlg, GET_WM_COMMAND_ID(wParam, lParam) == IDOK);
 
458
                                        return TRUE;
 
459
 
 
460
                                case IDAPPLY:
 
461
                                        driver_options_update(hdlg, ci, NULL);
 
462
                                        SendMessage(GetWindow(hdlg, GW_OWNER), WM_COMMAND, wParam, lParam);
 
463
                                        break;
 
464
 
 
465
                                case IDDEFAULTS:
 
466
                                        driver_optionsDraw(hdlg, ci, 0, FALSE);
 
467
                                        break;
 
468
 
 
469
                                case IDNEXTPAGE:
 
470
                                        driver_options_update(hdlg, ci, NULL);
 
471
 
 
472
                                        EndDialog(hdlg, FALSE);
 
473
                                        DialogBoxParam(s_hModule,
 
474
                                                MAKEINTRESOURCE(DLG_OPTIONS_DS),
 
475
                                                        hdlg, ds_options2Proc, (LPARAM)
 
476
ci);
 
477
                                        break;
 
478
                        }
 
479
        }
 
480
 
 
481
        return FALSE;
 
482
}
 
483
 
 
484
 
 
485
LRESULT                 CALLBACK
 
486
ds_options2Proc(HWND hdlg,
 
487
                           UINT wMsg,
 
488
                           WPARAM wParam,
 
489
                           LPARAM lParam)
 
490
{
 
491
        ConnInfo   *ci;
 
492
        char            buf[128];
 
493
        DWORD           cmd;
 
494
        BOOL            enable;
 
495
 
 
496
        switch (wMsg)
 
497
        {
 
498
                case WM_INITDIALOG:
 
499
                        ci = (ConnInfo *) lParam;
 
500
                        SetWindowLongPtr(hdlg, DWLP_USER, lParam);              /* save for OK */
 
501
 
 
502
                        /* Change window caption */
 
503
                        if (ci && ci->dsn && ci->dsn[0])
 
504
                        {
 
505
                                char    fbuf[64];
 
506
 
 
507
                                cmd = LoadString(s_hModule,
 
508
                                                IDS_ADVANCE_OPTION_DSN2,
 
509
                                                fbuf,
 
510
                                                sizeof(fbuf));
 
511
                                if (cmd <= 0)
 
512
                                        strcpy(fbuf, "Advanced Options (%s) 2/2");
 
513
                                sprintf(buf, fbuf, ci->dsn);
 
514
                                SetWindowText(hdlg, buf);
 
515
                        }
 
516
                        else
 
517
                        {
 
518
                                LoadString(s_hModule, IDS_ADVANCE_OPTION_CON2, buf, sizeof(buf)); 
 
519
                                SetWindowText(hdlg, buf);
 
520
                                ShowWindow(GetDlgItem(hdlg, IDAPPLY), SW_HIDE);                         }
 
521
 
 
522
                        /* Readonly */
 
523
                        CheckDlgButton(hdlg, DS_READONLY, atoi(ci->onlyread));
 
524
 
 
525
                        /* Protocol */
 
526
                        enable = (ci->sslmode[0] == SSLLBYTE_DISABLE || ci->username[0] == '\0');
 
527
                        EnableWindow(GetDlgItem(hdlg, DS_PG62), enable);
 
528
                        EnableWindow(GetDlgItem(hdlg, DS_PG63), enable);
 
529
                        EnableWindow(GetDlgItem(hdlg, DS_PG64), enable);
 
530
                        EnableWindow(GetDlgItem(hdlg, DS_PG74), enable);
 
531
                        if (PROTOCOL_62(ci))
 
532
                                CheckDlgButton(hdlg, DS_PG62, 1);
 
533
                        else if (PROTOCOL_63(ci))
 
534
                                CheckDlgButton(hdlg, DS_PG63, 1);
 
535
                        else if (PROTOCOL_64(ci))
 
536
                                CheckDlgButton(hdlg, DS_PG64, 1);
 
537
                        else
 
538
                                /* latest */
 
539
                                CheckDlgButton(hdlg, DS_PG74, 1);
 
540
 
 
541
                        /* How to issue Rollback */
 
542
                        switch (ci->rollback_on_error)
 
543
                        {
 
544
                                case 0:
 
545
                                        CheckDlgButton(hdlg, DS_NO_ROLLBACK, 1);
 
546
                                        break;
 
547
                                case 1:
 
548
                                        CheckDlgButton(hdlg, DS_TRANSACTION_ROLLBACK, 1);
 
549
                                        break;
 
550
                                case 2:
 
551
                                        CheckDlgButton(hdlg, DS_STATEMENT_ROLLBACK, 1);
 
552
                                        break;
 
553
                        }
 
554
 
 
555
                        /* Int8 As */
 
556
                        switch (ci->int8_as)
 
557
                        {
 
558
                                case SQL_BIGINT:
 
559
                                        CheckDlgButton(hdlg, DS_INT8_AS_BIGINT, 1);
 
560
                                        break;
 
561
                                case SQL_NUMERIC:
 
562
                                        CheckDlgButton(hdlg, DS_INT8_AS_NUMERIC, 1);
 
563
                                        break;
 
564
                                case SQL_VARCHAR:
 
565
                                        CheckDlgButton(hdlg, DS_INT8_AS_VARCHAR, 1);
 
566
                                        break;
 
567
                                case SQL_DOUBLE:
 
568
                                        CheckDlgButton(hdlg, DS_INT8_AS_DOUBLE, 1);
 
569
                                        break;
 
570
                                case SQL_INTEGER:
 
571
                                        CheckDlgButton(hdlg, DS_INT8_AS_INT4, 1);
 
572
                                        break;
 
573
                                default:
 
574
                                        CheckDlgButton(hdlg, DS_INT8_AS_DEFAULT, 1);
 
575
                        }
 
576
                        sprintf(buf, "0x%x", getExtraOptions(ci));
 
577
                        SetDlgItemText(hdlg, DS_EXTRA_OPTIONS, buf);
 
578
 
 
579
                        CheckDlgButton(hdlg, DS_SHOWOIDCOLUMN, atoi(ci->show_oid_column));
 
580
                        CheckDlgButton(hdlg, DS_FAKEOIDINDEX, atoi(ci->fake_oid_index));
 
581
                        CheckDlgButton(hdlg, DS_ROWVERSIONING, atoi(ci->row_versioning));
 
582
                        CheckDlgButton(hdlg, DS_SHOWSYSTEMTABLES, atoi(ci->show_system_tables));
 
583
                        CheckDlgButton(hdlg, DS_DISALLOWPREMATURE, ci->disallow_premature);
 
584
                        CheckDlgButton(hdlg, DS_LFCONVERSION, ci->lf_conversion);
 
585
                        CheckDlgButton(hdlg, DS_TRUEISMINUS1, ci->true_is_minus1);
 
586
                        CheckDlgButton(hdlg, DS_UPDATABLECURSORS, ci->allow_keyset);
 
587
                        CheckDlgButton(hdlg, DS_SERVERSIDEPREPARE, ci->use_server_side_prepare);
 
588
                        CheckDlgButton(hdlg, DS_BYTEAASLONGVARBINARY, ci->bytea_as_longvarbinary);
 
589
                        /*CheckDlgButton(hdlg, DS_LOWERCASEIDENTIFIER, ci->lower_case_identifier);*/
 
590
                        CheckDlgButton(hdlg, DS_GSSAUTHUSEGSSAPI, ci->gssauth_use_gssapi);
 
591
 
 
592
#if     defined(NOT_USE_LIBPQ) && !defined(USE_SSPI) && !defined(USE_GSS)
 
593
                        EnableWindow(GetDlgItem(hdlg, DS_GSSAUTHUSEGSSAPI), FALSE);
 
594
#endif
 
595
                        EnableWindow(GetDlgItem(hdlg, DS_FAKEOIDINDEX), atoi(ci->show_oid_column));
 
596
 
 
597
                        /* Datasource Connection Settings */
 
598
                        SetDlgItemText(hdlg, DS_CONNSETTINGS, ci->conn_settings);
 
599
                        break;
 
600
 
 
601
                case WM_COMMAND:
 
602
                        switch (cmd = GET_WM_COMMAND_ID(wParam, lParam))
 
603
                        {
 
604
                                case DS_SHOWOIDCOLUMN:
 
605
                                        mylog("WM_COMMAND: DS_SHOWOIDCOLUMN\n");
 
606
                                        EnableWindow(GetDlgItem(hdlg, DS_FAKEOIDINDEX), IsDlgButtonChecked(hdlg, DS_SHOWOIDCOLUMN));
 
607
                                        return TRUE;
 
608
 
 
609
                                case IDOK:
 
610
                                case IDAPPLY:
 
611
                                case IDPREVPAGE:
 
612
                                        ci = (ConnInfo *) GetWindowLongPtr(hdlg, DWLP_USER);
 
613
                                        mylog("IDOK: got ci = %p\n", ci);
 
614
 
 
615
                                        /* Readonly */
 
616
                                        sprintf(ci->onlyread, "%d", IsDlgButtonChecked(hdlg, DS_READONLY));
 
617
 
 
618
                                        /* Protocol */
 
619
                                        if (IsDlgButtonChecked(hdlg, DS_PG62))
 
620
                                                strcpy(ci->protocol, PG62);
 
621
                                        else if (IsDlgButtonChecked(hdlg, DS_PG63))
 
622
                                                strcpy(ci->protocol, PG63);
 
623
                                        else if (IsDlgButtonChecked(hdlg, DS_PG64))
 
624
                                                strcpy(ci->protocol, PG64);
 
625
                                        else
 
626
                                                /* latest */
 
627
                                                strcpy(ci->protocol, PG74);
 
628
 
 
629
                                        /* Issue rollback command on error */
 
630
                                        if (IsDlgButtonChecked(hdlg, DS_NO_ROLLBACK))
 
631
                                                ci->rollback_on_error = 0;
 
632
                                        else if (IsDlgButtonChecked(hdlg, DS_TRANSACTION_ROLLBACK))
 
633
                                                ci->rollback_on_error = 1;
 
634
                                        else if (IsDlgButtonChecked(hdlg, DS_STATEMENT_ROLLBACK))
 
635
                                                ci->rollback_on_error = 2;
 
636
                                        else
 
637
                                                /* legacy */
 
638
                                                ci->rollback_on_error = 1;
 
639
 
 
640
                                        /* Int8 As */
 
641
                                        if (IsDlgButtonChecked(hdlg, DS_INT8_AS_DEFAULT))
 
642
                                                ci->int8_as = 0;
 
643
                                        else if (IsDlgButtonChecked(hdlg, DS_INT8_AS_BIGINT))
 
644
                                                ci->int8_as = SQL_BIGINT;
 
645
                                        else if (IsDlgButtonChecked(hdlg, DS_INT8_AS_NUMERIC))
 
646
                                                ci->int8_as = SQL_NUMERIC;
 
647
                                        else if (IsDlgButtonChecked(hdlg, DS_INT8_AS_DOUBLE))
 
648
                                                ci->int8_as = SQL_DOUBLE;
 
649
                                        else if (IsDlgButtonChecked(hdlg, DS_INT8_AS_INT4))
 
650
                                                ci->int8_as = SQL_INTEGER;
 
651
                                        else
 
652
                                                ci->int8_as = SQL_VARCHAR;
 
653
 
 
654
                                        GetDlgItemText(hdlg, DS_EXTRA_OPTIONS, buf, sizeof(buf));
 
655
                                        setExtraOptions(ci, buf, NULL);
 
656
                                        sprintf(ci->show_system_tables, "%d", IsDlgButtonChecked(hdlg, DS_SHOWSYSTEMTABLES));
 
657
 
 
658
                                        sprintf(ci->row_versioning, "%d", IsDlgButtonChecked(hdlg, DS_ROWVERSIONING));
 
659
                                        ci->disallow_premature = IsDlgButtonChecked(hdlg, DS_DISALLOWPREMATURE);
 
660
                                        ci->lf_conversion = IsDlgButtonChecked(hdlg, DS_LFCONVERSION);
 
661
                                        ci->true_is_minus1 = IsDlgButtonChecked(hdlg, DS_TRUEISMINUS1);
 
662
                                        ci->allow_keyset = IsDlgButtonChecked(hdlg, DS_UPDATABLECURSORS);
 
663
                                        ci->use_server_side_prepare = IsDlgButtonChecked(hdlg, DS_SERVERSIDEPREPARE);
 
664
                                        ci->bytea_as_longvarbinary = IsDlgButtonChecked(hdlg, DS_BYTEAASLONGVARBINARY);
 
665
                                        /*ci->lower_case_identifier = IsDlgButtonChecked(hdlg, DS_LOWERCASEIDENTIFIER);*/
 
666
                                        ci->gssauth_use_gssapi = IsDlgButtonChecked(hdlg, DS_GSSAUTHUSEGSSAPI);
 
667
 
 
668
                                        /* OID Options */
 
669
                                        sprintf(ci->fake_oid_index, "%d", IsDlgButtonChecked(hdlg, DS_FAKEOIDINDEX));
 
670
                                        sprintf(ci->show_oid_column, "%d", IsDlgButtonChecked(hdlg, DS_SHOWOIDCOLUMN));
 
671
 
 
672
                                        /* Datasource Connection Settings */
 
673
                                        GetDlgItemText(hdlg, DS_CONNSETTINGS, ci->conn_settings, sizeof(ci->conn_settings));
 
674
                                        if (IDAPPLY == cmd)
 
675
                                        {
 
676
                                                SendMessage(GetWindow(hdlg, GW_OWNER), WM_COMMAND, wParam, lParam);
 
677
                                                break;
 
678
                                        }
 
679
 
 
680
                                        EndDialog(hdlg, cmd == IDOK);
 
681
                                        if (IDOK == cmd) 
 
682
                                                return TRUE;
 
683
                                        DialogBoxParam(s_hModule,
 
684
                                                MAKEINTRESOURCE(DLG_OPTIONS_DRV),
 
685
                                                hdlg, ds_options1Proc, (LPARAM) ci);
 
686
                                        break;
 
687
 
 
688
                                case IDCANCEL:
 
689
                                        EndDialog(hdlg, GET_WM_COMMAND_ID(wParam, lParam) == IDOK);
 
690
                                        return TRUE;
 
691
                        }
 
692
        }
 
693
 
 
694
        return FALSE;
 
695
}
 
696
 
 
697
typedef SQLRETURN (SQL_API *SQLAPIPROC)();
 
698
static int
 
699
makeDriversList(HWND lwnd, const ConnInfo *ci)
 
700
{
 
701
        HMODULE hmodule;
 
702
        SQLHENV henv;
 
703
        int     lcount = 0;
 
704
        LRESULT iidx;
 
705
        char    drvname[64], drvatt[128];
 
706
        SQLUSMALLINT    direction = SQL_FETCH_FIRST;
 
707
        SQLSMALLINT     drvncount, drvacount;
 
708
        SQLRETURN       ret;
 
709
        SQLAPIPROC      addr;
 
710
 
 
711
        hmodule = GetModuleHandle("ODBC32");
 
712
        if (!hmodule)   return lcount;
 
713
        addr = (SQLAPIPROC) GetProcAddress(hmodule, "SQLAllocEnv");
 
714
        if (!addr)      return lcount;
 
715
        ret = (*addr)(&henv);
 
716
        if (SQL_SUCCESS != ret) return lcount;
 
717
        do
 
718
        {
 
719
                ret = SQLDrivers(henv, direction,
 
720
                        drvname, sizeof(drvname), &drvncount, 
 
721
                        drvatt, sizeof(drvatt), &drvacount); 
 
722
                if (SQL_SUCCESS != ret && SQL_SUCCESS_WITH_INFO != ret)
 
723
                        break;
 
724
                if (strnicmp(drvname, "postgresql", 10) == 0)
 
725
                {
 
726
                        iidx = SendMessage(lwnd, LB_ADDSTRING, 0, (LPARAM) drvname);
 
727
                        if (LB_ERR != iidx && stricmp(drvname, ci->drivername) == 0)
 
728
{
 
729
                                SendMessage(lwnd, LB_SETCURSEL, (WPARAM) iidx, (LPARAM) 0);
 
730
}
 
731
                        lcount++;
 
732
                }
 
733
                direction = SQL_FETCH_NEXT;
 
734
        } while (1);
 
735
        addr = (SQLAPIPROC) GetProcAddress(hmodule, "SQLFreeEnv");
 
736
        if (addr)
 
737
                (*addr)(henv);
 
738
 
 
739
        return lcount;
 
740
}
 
741
 
 
742
LRESULT         CALLBACK
 
743
manage_dsnProc(HWND hdlg, UINT wMsg,
 
744
                WPARAM wParam, LPARAM lParam)
 
745
{
 
746
        LPSETUPDLG      lpsetupdlg;
 
747
        ConnInfo        *ci;
 
748
        HWND            lwnd;
 
749
        LRESULT         sidx;
 
750
        char            drvname[64];
 
751
 
 
752
        switch (wMsg)
 
753
        {
 
754
                case WM_INITDIALOG:
 
755
                        SetWindowLongPtr(hdlg, DWLP_USER, lParam);
 
756
                        lpsetupdlg = (LPSETUPDLG) lParam;
 
757
                        ci = &lpsetupdlg->ci;
 
758
                        lwnd = GetDlgItem(hdlg, IDC_DRIVER_LIST);
 
759
                        makeDriversList(lwnd, ci);
 
760
                        break;
 
761
 
 
762
                case WM_COMMAND:
 
763
                        switch (GET_WM_COMMAND_ID(wParam, lParam))
 
764
                        {
 
765
                                case IDOK:
 
766
                                        lpsetupdlg = (LPSETUPDLG) GetWindowLongPtr(hdlg, DWLP_USER);
 
767
                                        lwnd = GetDlgItem(hdlg, IDC_DRIVER_LIST);
 
768
                                        sidx = SendMessage(lwnd, LB_GETCURSEL,
 
769
                                                (WPARAM) 0, (LPARAM) 0);
 
770
                                        if (LB_ERR == sidx)
 
771
                                                return FALSE;
 
772
                                        sidx = SendMessage(lwnd, LB_GETTEXT,
 
773
                                                (WPARAM) sidx, (LPARAM) drvname);
 
774
                                        if (LB_ERR == sidx)
 
775
                                                return FALSE;
 
776
                                        ChangeDriverName(hdlg, lpsetupdlg, drvname);
 
777
 
 
778
                                case IDCANCEL:
 
779
                                        EndDialog(hdlg, GET_WM_COMMAND_ID(wParam, lParam) == IDOK);
 
780
                                        return TRUE;
 
781
                        }
 
782
        }
 
783
 
 
784
        return FALSE;
 
785
}
 
786
 
 
787
#endif /* WIN32 */