gwj / at91sam9263 · Commits

Commit 28a76be8f4536619ab15ce452308df78cfc65e39

Authored by aliguori
1 parent 76655d6d

Remove tabs introduced from VNC ACL series 

Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6727 c046a42c-6fe2-441c-8c8c-71466251a162
Inline Side-by-side
Showing 4 changed files with 736 additions and 736 deletions
... ... @@ -41,8 +41,8 @@ qemu_acl *qemu_acl_find(const char *aclname)
41 41 {
42 42 int i;
43 43 for (i = 0 ; i < nacls ; i++) {
44   - if (strcmp(acls[i]->aclname, aclname) == 0)
45   - return acls[i];
  44 + if (strcmp(acls[i]->aclname, aclname) == 0)
  45 + return acls[i];
46 46 }
47 47  
48 48 return NULL;
... ... @@ -54,7 +54,7 @@ qemu_acl *qemu_acl_init(const char *aclname)
54 54  
55 55 acl = qemu_acl_find(aclname);
56 56 if (acl)
57   - return acl;
  57 + return acl;
58 58  
59 59 acl = qemu_malloc(sizeof(*acl));
60 60 acl->aclname = qemu_strdup(aclname);
... ... @@ -74,19 +74,19 @@ qemu_acl *qemu_acl_init(const char *aclname)
74 74 }
75 75  
76 76 int qemu_acl_party_is_allowed(qemu_acl *acl,
77   - const char *party)
  77 + const char *party)
78 78 {
79 79 qemu_acl_entry *entry;
80 80  
81 81 TAILQ_FOREACH(entry, &acl->entries, next) {
82 82 #ifdef HAVE_FNMATCH_H
83   - if (fnmatch(entry->match, party, 0) == 0)
84   - return entry->deny ? 0 : 1;
  83 + if (fnmatch(entry->match, party, 0) == 0)
  84 + return entry->deny ? 0 : 1;
85 85 #else
86   - /* No fnmatch, so fallback to exact string matching
87   - * instead of allowing wildcards */
88   - if (strcmp(entry->match, party) == 0)
89   - return entry->deny ? 0 : 1;
  86 + /* No fnmatch, so fallback to exact string matching
  87 + * instead of allowing wildcards */
  88 + if (strcmp(entry->match, party) == 0)
  89 + return entry->deny ? 0 : 1;
90 90 #endif
91 91 }
92 92  
... ... @@ -103,17 +103,17 @@ void qemu_acl_reset(qemu_acl *acl)
103 103 * access control list */
104 104 acl->defaultDeny = 1;
105 105 TAILQ_FOREACH(entry, &acl->entries, next) {
106   - TAILQ_REMOVE(&acl->entries, entry, next);
107   - free(entry->match);
108   - free(entry);
  106 + TAILQ_REMOVE(&acl->entries, entry, next);
  107 + free(entry->match);
  108 + free(entry);
109 109 }
110 110 acl->nentries = 0;
111 111 }
112 112  
113 113  
114 114 int qemu_acl_append(qemu_acl *acl,
115   - int deny,
116   - const char *match)
  115 + int deny,
  116 + const char *match)
117 117 {
118 118 qemu_acl_entry *entry;
119 119  
... ... @@ -129,18 +129,18 @@ int qemu_acl_append(qemu_acl *acl,
129 129  
130 130  
131 131 int qemu_acl_insert(qemu_acl *acl,
132   - int deny,
133   - const char *match,
134   - int index)
  132 + int deny,
  133 + const char *match,
  134 + int index)
135 135 {
136 136 qemu_acl_entry *entry;
137 137 qemu_acl_entry *tmp;
138 138 int i = 0;
139 139  
140 140 if (index <= 0)
141   - return -1;
  141 + return -1;
142 142 if (index >= acl->nentries)
143   - return qemu_acl_append(acl, deny, match);
  143 + return qemu_acl_append(acl, deny, match);
144 144  
145 145  
146 146 entry = qemu_malloc(sizeof(*entry));
... ... @@ -148,29 +148,29 @@ int qemu_acl_insert(qemu_acl *acl,
148 148 entry->deny = deny;
149 149  
150 150 TAILQ_FOREACH(tmp, &acl->entries, next) {
151   - i++;
152   - if (i == index) {
153   - TAILQ_INSERT_BEFORE(tmp, entry, next);
154   - acl->nentries++;
155   - break;
156   - }
  151 + i++;
  152 + if (i == index) {
  153 + TAILQ_INSERT_BEFORE(tmp, entry, next);
  154 + acl->nentries++;
  155 + break;
  156 + }
157 157 }
158 158  
159 159 return i;
160 160 }
161 161  
162 162 int qemu_acl_remove(qemu_acl *acl,
163   - const char *match)
  163 + const char *match)
164 164 {
165 165 qemu_acl_entry *entry;
166 166 int i = 0;
167 167  
168 168 TAILQ_FOREACH(entry, &acl->entries, next) {
169   - i++;
170   - if (strcmp(entry->match, match) == 0) {
171   - TAILQ_REMOVE(&acl->entries, entry, next);
172   - return i;
173   - }
  169 + i++;
  170 + if (strcmp(entry->match, match) == 0) {
  171 + TAILQ_REMOVE(&acl->entries, entry, next);
  172 + return i;
  173 + }
174 174 }
175 175 return -1;
176 176 }
... ...
monitor.c
  View file @28a76be
... ... @@ -160,25 +160,25 @@ void monitor_print_filename(Monitor *mon, const char *filename)
160 160 int i;
161 161  
162 162 for (i = 0; filename[i]; i++) {
163   - switch (filename[i]) {
164   - case ' ':
165   - case '"':
166   - case '\\':
167   - monitor_printf(mon, "\\%c", filename[i]);
168   - break;
169   - case '\t':
170   - monitor_printf(mon, "\\t");
171   - break;
172   - case '\r':
173   - monitor_printf(mon, "\\r");
174   - break;
175   - case '\n':
176   - monitor_printf(mon, "\\n");
177   - break;
178   - default:
179   - monitor_printf(mon, "%c", filename[i]);
180   - break;
181   - }
  163 + switch (filename[i]) {
  164 + case ' ':
  165 + case '"':
  166 + case '\\':
  167 + monitor_printf(mon, "\\%c", filename[i]);
  168 + break;
  169 + case '\t':
  170 + monitor_printf(mon, "\\t");
  171 + break;
  172 + case '\r':
  173 + monitor_printf(mon, "\\r");
  174 + break;
  175 + case '\n':
  176 + monitor_printf(mon, "\\n");
  177 + break;
  178 + default:
  179 + monitor_printf(mon, "%c", filename[i]);
  180 + break;
  181 + }
182 182 }
183 183 }
184 184  
... ... @@ -474,17 +474,17 @@ static void change_vnc_password_cb(Monitor *mon, const char *password,
474 474 static void do_change_vnc(Monitor *mon, const char *target, const char *arg)
475 475 {
476 476 if (strcmp(target, "passwd") == 0 ||
477   - strcmp(target, "password") == 0) {
478   - if (arg) {
  477 + strcmp(target, "password") == 0) {
  478 + if (arg) {
479 479 char password[9];
480   - strncpy(password, arg, sizeof(password));
481   - password[sizeof(password) - 1] = '\0';
  480 + strncpy(password, arg, sizeof(password));
  481 + password[sizeof(password) - 1] = '\0';
482 482 change_vnc_password_cb(mon, password, NULL);
483 483 } else {
484 484 monitor_read_password(mon, change_vnc_password_cb, NULL);
485 485 }
486 486 } else {
487   - if (vnc_display_open(NULL, target) < 0)
  487 + if (vnc_display_open(NULL, target) < 0)
488 488 monitor_printf(mon, "could not start VNC server on %s\n", target);
489 489 }
490 490 }
... ... @@ -493,9 +493,9 @@ static void do_change(Monitor *mon, const char *device, const char *target,
493 493 const char *arg)
494 494 {
495 495 if (strcmp(device, "vnc") == 0) {
496   - do_change_vnc(mon, target, arg);
  496 + do_change_vnc(mon, target, arg);
497 497 } else {
498   - do_change_block(mon, device, target, arg);
  498 + do_change_block(mon, device, target, arg);
499 499 }
500 500 }
501 501  
... ... @@ -1535,81 +1535,81 @@ static void do_info_balloon(Monitor *mon)
1535 1535  
1536 1536 static void do_acl(Monitor *mon,
1537 1537 const char *command,
1538   - const char *aclname,
1539   - const char *match,
1540   - int has_index,
1541   - int index)
  1538 + const char *aclname,
  1539 + const char *match,
  1540 + int has_index,
  1541 + int index)
1542 1542 {
1543 1543 qemu_acl *acl;
1544 1544  
1545 1545 acl = qemu_acl_find(aclname);
1546 1546 if (!acl) {
1547   - monitor_printf(mon, "acl: unknown list '%s'\n", aclname);
1548   - return;
  1547 + monitor_printf(mon, "acl: unknown list '%s'\n", aclname);
  1548 + return;
1549 1549 }
1550 1550  
1551 1551 if (strcmp(command, "show") == 0) {
1552   - int i = 0;
1553   - qemu_acl_entry *entry;
1554   - monitor_printf(mon, "policy: %s\n",
  1552 + int i = 0;
  1553 + qemu_acl_entry *entry;
  1554 + monitor_printf(mon, "policy: %s\n",
1555 1555 acl->defaultDeny ? "deny" : "allow");
1556   - TAILQ_FOREACH(entry, &acl->entries, next) {
1557   - i++;
1558   - monitor_printf(mon, "%d: %s %s\n", i,
  1556 + TAILQ_FOREACH(entry, &acl->entries, next) {
  1557 + i++;
  1558 + monitor_printf(mon, "%d: %s %s\n", i,
1559 1559 entry->deny ? "deny" : "allow",
1560 1560 entry->match);
1561   - }
  1561 + }
1562 1562 } else if (strcmp(command, "reset") == 0) {
1563   - qemu_acl_reset(acl);
1564   - monitor_printf(mon, "acl: removed all rules\n");
  1563 + qemu_acl_reset(acl);
  1564 + monitor_printf(mon, "acl: removed all rules\n");
1565 1565 } else if (strcmp(command, "policy") == 0) {
1566   - if (!match) {
1567   - monitor_printf(mon, "acl: missing policy parameter\n");
1568   - return;
1569   - }
1570   -
1571   - if (strcmp(match, "allow") == 0) {
1572   - acl->defaultDeny = 0;
1573   - monitor_printf(mon, "acl: policy set to 'allow'\n");
1574   - } else if (strcmp(match, "deny") == 0) {
1575   - acl->defaultDeny = 1;
1576   - monitor_printf(mon, "acl: policy set to 'deny'\n");
1577   - } else {
1578   - monitor_printf(mon, "acl: unknown policy '%s', expected 'deny' or 'allow'\n", match);
1579   - }
  1566 + if (!match) {
  1567 + monitor_printf(mon, "acl: missing policy parameter\n");
  1568 + return;
  1569 + }
  1570 +
  1571 + if (strcmp(match, "allow") == 0) {
  1572 + acl->defaultDeny = 0;
  1573 + monitor_printf(mon, "acl: policy set to 'allow'\n");
  1574 + } else if (strcmp(match, "deny") == 0) {
  1575 + acl->defaultDeny = 1;
  1576 + monitor_printf(mon, "acl: policy set to 'deny'\n");
  1577 + } else {
  1578 + monitor_printf(mon, "acl: unknown policy '%s', expected 'deny' or 'allow'\n", match);
  1579 + }
1580 1580 } else if ((strcmp(command, "allow") == 0) ||
1581   - (strcmp(command, "deny") == 0)) {
1582   - int deny = strcmp(command, "deny") == 0 ? 1 : 0;
1583   - int ret;
1584   -
1585   - if (!match) {
1586   - monitor_printf(mon, "acl: missing match parameter\n");
1587   - return;
1588   - }
1589   -
1590   - if (has_index)
1591   - ret = qemu_acl_insert(acl, deny, match, index);
1592   - else
1593   - ret = qemu_acl_append(acl, deny, match);
1594   - if (ret < 0)
1595   - monitor_printf(mon, "acl: unable to add acl entry\n");
1596   - else
1597   - monitor_printf(mon, "acl: added rule at position %d\n", ret);
  1581 + (strcmp(command, "deny") == 0)) {
  1582 + int deny = strcmp(command, "deny") == 0 ? 1 : 0;
  1583 + int ret;
  1584 +
  1585 + if (!match) {
  1586 + monitor_printf(mon, "acl: missing match parameter\n");
  1587 + return;
  1588 + }
  1589 +
  1590 + if (has_index)
  1591 + ret = qemu_acl_insert(acl, deny, match, index);
  1592 + else
  1593 + ret = qemu_acl_append(acl, deny, match);
  1594 + if (ret < 0)
  1595 + monitor_printf(mon, "acl: unable to add acl entry\n");
  1596 + else
  1597 + monitor_printf(mon, "acl: added rule at position %d\n", ret);
1598 1598 } else if (strcmp(command, "remove") == 0) {
1599   - int ret;
1600   -
1601   - if (!match) {
1602   - monitor_printf(mon, "acl: missing match parameter\n");
1603   - return;
1604   - }
1605   -
1606   - ret = qemu_acl_remove(acl, match);
1607   - if (ret < 0)
1608   - monitor_printf(mon, "acl: no matching acl entry\n");
1609   - else
1610   - monitor_printf(mon, "acl: removed rule at position %d\n", ret);
  1599 + int ret;
  1600 +
  1601 + if (!match) {
  1602 + monitor_printf(mon, "acl: missing match parameter\n");
  1603 + return;
  1604 + }
  1605 +
  1606 + ret = qemu_acl_remove(acl, match);
  1607 + if (ret < 0)
  1608 + monitor_printf(mon, "acl: no matching acl entry\n");
  1609 + else
  1610 + monitor_printf(mon, "acl: removed rule at position %d\n", ret);
1611 1611 } else {
1612   - monitor_printf(mon, "acl: unknown command '%s'\n", command);
  1612 + monitor_printf(mon, "acl: unknown command '%s'\n", command);
1613 1613 }
1614 1614 }
1615 1615  
... ... @@ -1839,7 +1839,7 @@ static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
1839 1839  
1840 1840 u = 0;
1841 1841 for (i = 0; i < 8; i++)
1842   - u |= env->crf[i] << (32 - (4 * i));
  1842 + u |= env->crf[i] << (32 - (4 * i));
1843 1843  
1844 1844 return u;
1845 1845 }
... ...
vnc-auth-sasl.c
  View file @28a76be
... ... @@ -31,14 +31,14 @@
31 31 void vnc_sasl_client_cleanup(VncState *vs)
32 32 {
33 33 if (vs->sasl.conn) {
34   - vs->sasl.runSSF = vs->sasl.waitWriteSSF = vs->sasl.wantSSF = 0;
35   - vs->sasl.encodedLength = vs->sasl.encodedOffset = 0;
36   - vs->sasl.encoded = NULL;
37   - free(vs->sasl.username);
38   - free(vs->sasl.mechlist);
39   - vs->sasl.username = vs->sasl.mechlist = NULL;
40   - sasl_dispose(&vs->sasl.conn);
41   - vs->sasl.conn = NULL;
  34 + vs->sasl.runSSF = vs->sasl.waitWriteSSF = vs->sasl.wantSSF = 0;
  35 + vs->sasl.encodedLength = vs->sasl.encodedOffset = 0;
  36 + vs->sasl.encoded = NULL;
  37 + free(vs->sasl.username);
  38 + free(vs->sasl.mechlist);
  39 + vs->sasl.username = vs->sasl.mechlist = NULL;
  40 + sasl_dispose(&vs->sasl.conn);
  41 + vs->sasl.conn = NULL;
42 42 }
43 43 }
44 44  
... ... @@ -48,33 +48,33 @@ long vnc_client_write_sasl(VncState *vs)
48 48 long ret;
49 49  
50 50 VNC_DEBUG("Write SASL: Pending output %p size %d offset %d Encoded: %p size %d offset %d\n",
51   - vs->output.buffer, vs->output.capacity, vs->output.offset,
52   - vs->sasl.encoded, vs->sasl.encodedLength, vs->sasl.encodedOffset);
  51 + vs->output.buffer, vs->output.capacity, vs->output.offset,
  52 + vs->sasl.encoded, vs->sasl.encodedLength, vs->sasl.encodedOffset);
53 53  
54 54 if (!vs->sasl.encoded) {
55   - int err;
56   - err = sasl_encode(vs->sasl.conn,
57   - (char *)vs->output.buffer,
58   - vs->output.offset,
59   - (const char **)&vs->sasl.encoded,
60   - &vs->sasl.encodedLength);
61   - if (err != SASL_OK)
62   - return vnc_client_io_error(vs, -1, EIO);
63   -
64   - vs->sasl.encodedOffset = 0;
  55 + int err;
  56 + err = sasl_encode(vs->sasl.conn,
  57 + (char *)vs->output.buffer,
  58 + vs->output.offset,
  59 + (const char **)&vs->sasl.encoded,
  60 + &vs->sasl.encodedLength);
  61 + if (err != SASL_OK)
  62 + return vnc_client_io_error(vs, -1, EIO);
  63 +
  64 + vs->sasl.encodedOffset = 0;
65 65 }
66 66  
67 67 ret = vnc_client_write_buf(vs,
68   - vs->sasl.encoded + vs->sasl.encodedOffset,
69   - vs->sasl.encodedLength - vs->sasl.encodedOffset);
  68 + vs->sasl.encoded + vs->sasl.encodedOffset,
  69 + vs->sasl.encodedLength - vs->sasl.encodedOffset);
70 70 if (!ret)
71   - return 0;
  71 + return 0;
72 72  
73 73 vs->sasl.encodedOffset += ret;
74 74 if (vs->sasl.encodedOffset == vs->sasl.encodedLength) {
75   - vs->output.offset = 0;
76   - vs->sasl.encoded = NULL;
77   - vs->sasl.encodedOffset = vs->sasl.encodedLength = 0;
  75 + vs->output.offset = 0;
  76 + vs->sasl.encoded = NULL;
  77 + vs->sasl.encodedOffset = vs->sasl.encodedLength = 0;
78 78 }
79 79  
80 80 /* Can't merge this block with one above, because
... ... @@ -83,7 +83,7 @@ long vnc_client_write_sasl(VncState *vs)
83 83 * SASL encoded output
84 84 */
85 85 if (vs->output.offset == 0) {
86   - qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
  86 + qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
87 87 }
88 88  
89 89 return ret;
... ... @@ -100,16 +100,16 @@ long vnc_client_read_sasl(VncState *vs)
100 100  
101 101 ret = vnc_client_read_buf(vs, encoded, sizeof(encoded));
102 102 if (!ret)
103   - return 0;
  103 + return 0;
104 104  
105 105 err = sasl_decode(vs->sasl.conn,
106   - (char *)encoded, ret,
107   - &decoded, &decodedLen);
  106 + (char *)encoded, ret,
  107 + &decoded, &decodedLen);
108 108  
109 109 if (err != SASL_OK)
110   - return vnc_client_io_error(vs, -1, -EIO);
  110 + return vnc_client_io_error(vs, -1, -EIO);
111 111 VNC_DEBUG("Read SASL Encoded %p size %ld Decoded %p size %d\n",
112   - encoded, ret, decoded, decodedLen);
  112 + encoded, ret, decoded, decodedLen);
113 113 buffer_reserve(&vs->input, decodedLen);
114 114 buffer_append(&vs->input, decoded, decodedLen);
115 115 return decodedLen;
... ... @@ -124,27 +124,27 @@ static int vnc_auth_sasl_check_access(VncState *vs)
124 124  
125 125 err = sasl_getprop(vs->sasl.conn, SASL_USERNAME, &val);
126 126 if (err != SASL_OK) {
127   - VNC_DEBUG("cannot query SASL username on connection %d (%s), denying access\n",
128   - err, sasl_errstring(err, NULL, NULL));
129   - return -1;
  127 + VNC_DEBUG("cannot query SASL username on connection %d (%s), denying access\n",
  128 + err, sasl_errstring(err, NULL, NULL));
  129 + return -1;
130 130 }
131 131 if (val == NULL) {
132   - VNC_DEBUG("no client username was found, denying access\n");
133   - return -1;
  132 + VNC_DEBUG("no client username was found, denying access\n");
  133 + return -1;
134 134 }
135 135 VNC_DEBUG("SASL client username %s\n", (const char *)val);
136 136  
137 137 vs->sasl.username = qemu_strdup((const char*)val);
138 138  
139 139 if (vs->vd->sasl.acl == NULL) {
140   - VNC_DEBUG("no ACL activated, allowing access\n");
141   - return 0;
  140 + VNC_DEBUG("no ACL activated, allowing access\n");
  141 + return 0;
142 142 }
143 143  
144 144 allow = qemu_acl_party_is_allowed(vs->vd->sasl.acl, vs->sasl.username);
145 145  
146 146 VNC_DEBUG("SASL client %s %s by ACL\n", vs->sasl.username,
147   - allow ? "allowed" : "denied");
  147 + allow ? "allowed" : "denied");
148 148 return allow ? 0 : -1;
149 149 }
150 150  
... ... @@ -154,16 +154,16 @@ static int vnc_auth_sasl_check_ssf(VncState *vs)
154 154 int err, ssf;
155 155  
156 156 if (!vs->sasl.wantSSF)
157   - return 1;
  157 + return 1;
158 158  
159 159 err = sasl_getprop(vs->sasl.conn, SASL_SSF, &val);
160 160 if (err != SASL_OK)
161   - return 0;
  161 + return 0;
162 162  
163 163 ssf = *(const int *)val;
164 164 VNC_DEBUG("negotiated an SSF of %d\n", ssf);
165 165 if (ssf < 56)
166   - return 0; /* 56 is good for Kerberos */
  166 + return 0; /* 56 is good for Kerberos */
167 167  
168 168 /* Only setup for read initially, because we're about to send an RPC
169 169 * reply which must be in plain text. When the next incoming RPC
... ... @@ -204,73 +204,73 @@ static int protocol_client_auth_sasl_step(VncState *vs, uint8_t *data, size_t le
204 204  
205 205 /* NB, distinction of NULL vs "" is *critical* in SASL */
206 206 if (datalen) {
207   - clientdata = (char*)data;
208   - clientdata[datalen-1] = '\0'; /* Wire includes '\0', but make sure */
209   - datalen--; /* Don't count NULL byte when passing to _start() */
  207 + clientdata = (char*)data;
  208 + clientdata[datalen-1] = '\0'; /* Wire includes '\0', but make sure */
  209 + datalen--; /* Don't count NULL byte when passing to _start() */
210 210 }
211 211  
212 212 VNC_DEBUG("Step using SASL Data %p (%d bytes)\n",
213   - clientdata, datalen);
  213 + clientdata, datalen);
214 214 err = sasl_server_step(vs->sasl.conn,
215   - clientdata,
216   - datalen,
217   - &serverout,
218   - &serveroutlen);
  215 + clientdata,
  216 + datalen,
  217 + &serverout,
  218 + &serveroutlen);
219 219 if (err != SASL_OK &&
220   - err != SASL_CONTINUE) {
221   - VNC_DEBUG("sasl step failed %d (%s)\n",
222   - err, sasl_errdetail(vs->sasl.conn));
223   - sasl_dispose(&vs->sasl.conn);
224   - vs->sasl.conn = NULL;
225   - goto authabort;
  220 + err != SASL_CONTINUE) {
  221 + VNC_DEBUG("sasl step failed %d (%s)\n",
  222 + err, sasl_errdetail(vs->sasl.conn));
  223 + sasl_dispose(&vs->sasl.conn);
  224 + vs->sasl.conn = NULL;
  225 + goto authabort;
226 226 }
227 227  
228 228 if (serveroutlen > SASL_DATA_MAX_LEN) {
229   - VNC_DEBUG("sasl step reply data too long %d\n",
230   - serveroutlen);
231   - sasl_dispose(&vs->sasl.conn);
232   - vs->sasl.conn = NULL;
233   - goto authabort;
  229 + VNC_DEBUG("sasl step reply data too long %d\n",
  230 + serveroutlen);
  231 + sasl_dispose(&vs->sasl.conn);
  232 + vs->sasl.conn = NULL;
  233 + goto authabort;
234 234 }
235 235  
236 236 VNC_DEBUG("SASL return data %d bytes, nil; %d\n",
237   - serveroutlen, serverout ? 0 : 1);
  237 + serveroutlen, serverout ? 0 : 1);
238 238  
239 239 if (serveroutlen) {
240   - vnc_write_u32(vs, serveroutlen + 1);
241   - vnc_write(vs, serverout, serveroutlen + 1);
  240 + vnc_write_u32(vs, serveroutlen + 1);
  241 + vnc_write(vs, serverout, serveroutlen + 1);
242 242 } else {
243   - vnc_write_u32(vs, 0);
  243 + vnc_write_u32(vs, 0);
244 244 }
245 245  
246 246 /* Whether auth is complete */
247 247 vnc_write_u8(vs, err == SASL_CONTINUE ? 0 : 1);
248 248  
249 249 if (err == SASL_CONTINUE) {
250   - VNC_DEBUG("%s", "Authentication must continue\n");
251   - /* Wait for step length */
252   - vnc_read_when(vs, protocol_client_auth_sasl_step_len, 4);
  250 + VNC_DEBUG("%s", "Authentication must continue\n");
  251 + /* Wait for step length */
  252 + vnc_read_when(vs, protocol_client_auth_sasl_step_len, 4);
253 253 } else {
254   - if (!vnc_auth_sasl_check_ssf(vs)) {
255   - VNC_DEBUG("Authentication rejected for weak SSF %d\n", vs->csock);
256   - goto authreject;
257   - }
258   -
259   - /* Check username whitelist ACL */
260   - if (vnc_auth_sasl_check_access(vs) < 0) {
261   - VNC_DEBUG("Authentication rejected for ACL %d\n", vs->csock);
262   - goto authreject;
263   - }
264   -
265   - VNC_DEBUG("Authentication successful %d\n", vs->csock);
266   - vnc_write_u32(vs, 0); /* Accept auth */
267   - /*
268   - * Delay writing in SSF encoded mode until pending output
269   - * buffer is written
270   - */
271   - if (vs->sasl.runSSF)
272   - vs->sasl.waitWriteSSF = vs->output.offset;
273   - start_client_init(vs);
  254 + if (!vnc_auth_sasl_check_ssf(vs)) {
  255 + VNC_DEBUG("Authentication rejected for weak SSF %d\n", vs->csock);
  256 + goto authreject;
  257 + }
  258 +
  259 + /* Check username whitelist ACL */
  260 + if (vnc_auth_sasl_check_access(vs) < 0) {
  261 + VNC_DEBUG("Authentication rejected for ACL %d\n", vs->csock);
  262 + goto authreject;
  263 + }
  264 +
  265 + VNC_DEBUG("Authentication successful %d\n", vs->csock);
  266 + vnc_write_u32(vs, 0); /* Accept auth */
  267 + /*
  268 + * Delay writing in SSF encoded mode until pending output
  269 + * buffer is written
  270 + */
  271 + if (vs->sasl.runSSF)
  272 + vs->sasl.waitWriteSSF = vs->output.offset;
  273 + start_client_init(vs);
274 274 }
275 275  
276 276 return 0;
... ... @@ -293,15 +293,15 @@ static int protocol_client_auth_sasl_step_len(VncState *vs, uint8_t *data, size_
293 293 uint32_t steplen = read_u32(data, 0);
294 294 VNC_DEBUG("Got client step len %d\n", steplen);
295 295 if (steplen > SASL_DATA_MAX_LEN) {
296   - VNC_DEBUG("Too much SASL data %d\n", steplen);
297   - vnc_client_error(vs);
298   - return -1;
  296 + VNC_DEBUG("Too much SASL data %d\n", steplen);
  297 + vnc_client_error(vs);
  298 + return -1;
299 299 }
300 300  
301 301 if (steplen == 0)
302   - return protocol_client_auth_sasl_step(vs, NULL, 0);
  302 + return protocol_client_auth_sasl_step(vs, NULL, 0);
303 303 else
304   - vnc_read_when(vs, protocol_client_auth_sasl_step, steplen);
  304 + vnc_read_when(vs, protocol_client_auth_sasl_step, steplen);
305 305 return 0;
306 306 }
307 307  
... ... @@ -332,67 +332,67 @@ static int protocol_client_auth_sasl_start(VncState *vs, uint8_t *data, size_t l
332 332  
333 333 /* NB, distinction of NULL vs "" is *critical* in SASL */
334 334 if (datalen) {
335   - clientdata = (char*)data;
336   - clientdata[datalen-1] = '\0'; /* Should be on wire, but make sure */
337   - datalen--; /* Don't count NULL byte when passing to _start() */
  335 + clientdata = (char*)data;
  336 + clientdata[datalen-1] = '\0'; /* Should be on wire, but make sure */
  337 + datalen--; /* Don't count NULL byte when passing to _start() */
338 338 }
339 339  
340 340 VNC_DEBUG("Start SASL auth with mechanism %s. Data %p (%d bytes)\n",
341   - vs->sasl.mechlist, clientdata, datalen);
  341 + vs->sasl.mechlist, clientdata, datalen);
342 342 err = sasl_server_start(vs->sasl.conn,
343   - vs->sasl.mechlist,
344   - clientdata,
345   - datalen,
346   - &serverout,
347   - &serveroutlen);
  343 + vs->sasl.mechlist,
  344 + clientdata,
  345 + datalen,
  346 + &serverout,
  347 + &serveroutlen);
348 348 if (err != SASL_OK &&
349   - err != SASL_CONTINUE) {
350   - VNC_DEBUG("sasl start failed %d (%s)\n",
351   - err, sasl_errdetail(vs->sasl.conn));
352   - sasl_dispose(&vs->sasl.conn);
353   - vs->sasl.conn = NULL;
354   - goto authabort;
  349 + err != SASL_CONTINUE) {
  350 + VNC_DEBUG("sasl start failed %d (%s)\n",
  351 + err, sasl_errdetail(vs->sasl.conn));
  352 + sasl_dispose(&vs->sasl.conn);
  353 + vs->sasl.conn = NULL;
  354 + goto authabort;
355 355 }
356 356 if (serveroutlen > SASL_DATA_MAX_LEN) {
357   - VNC_DEBUG("sasl start reply data too long %d\n",
358   - serveroutlen);
359   - sasl_dispose(&vs->sasl.conn);
360   - vs->sasl.conn = NULL;
361   - goto authabort;
  357 + VNC_DEBUG("sasl start reply data too long %d\n",
  358 + serveroutlen);
  359 + sasl_dispose(&vs->sasl.conn);
  360 + vs->sasl.conn = NULL;
  361 + goto authabort;
362 362 }
363 363  
364 364 VNC_DEBUG("SASL return data %d bytes, nil; %d\n",
365   - serveroutlen, serverout ? 0 : 1);
  365 + serveroutlen, serverout ? 0 : 1);
366 366  
367 367 if (serveroutlen) {
368   - vnc_write_u32(vs, serveroutlen + 1);
369   - vnc_write(vs, serverout, serveroutlen + 1);
  368 + vnc_write_u32(vs, serveroutlen + 1);
  369 + vnc_write(vs, serverout, serveroutlen + 1);
370 370 } else {
371   - vnc_write_u32(vs, 0);
  371 + vnc_write_u32(vs, 0);
372 372 }
373 373  
374 374 /* Whether auth is complete */
375 375 vnc_write_u8(vs, err == SASL_CONTINUE ? 0 : 1);
376 376  
377 377 if (err == SASL_CONTINUE) {
378   - VNC_DEBUG("%s", "Authentication must continue\n");
379   - /* Wait for step length */
380   - vnc_read_when(vs, protocol_client_auth_sasl_step_len, 4);
  378 + VNC_DEBUG("%s", "Authentication must continue\n");
  379 + /* Wait for step length */
  380 + vnc_read_when(vs, protocol_client_auth_sasl_step_len, 4);
381 381 } else {
382   - if (!vnc_auth_sasl_check_ssf(vs)) {
383   - VNC_DEBUG("Authentication rejected for weak SSF %d\n", vs->csock);
384   - goto authreject;
385   - }
386   -
387   - /* Check username whitelist ACL */
388   - if (vnc_auth_sasl_check_access(vs) < 0) {
389   - VNC_DEBUG("Authentication rejected for ACL %d\n", vs->csock);
390   - goto authreject;
391   - }
392   -
393   - VNC_DEBUG("Authentication successful %d\n", vs->csock);
394   - vnc_write_u32(vs, 0); /* Accept auth */
395   - start_client_init(vs);
  382 + if (!vnc_auth_sasl_check_ssf(vs)) {
  383 + VNC_DEBUG("Authentication rejected for weak SSF %d\n", vs->csock);
  384 + goto authreject;
  385 + }
  386 +
  387 + /* Check username whitelist ACL */
  388 + if (vnc_auth_sasl_check_access(vs) < 0) {
  389 + VNC_DEBUG("Authentication rejected for ACL %d\n", vs->csock);
  390 + goto authreject;
  391 + }
  392 +
  393 + VNC_DEBUG("Authentication successful %d\n", vs->csock);
  394 + vnc_write_u32(vs, 0); /* Accept auth */
  395 + start_client_init(vs);
396 396 }
397 397  
398 398 return 0;
... ... @@ -415,13 +415,13 @@ static int protocol_client_auth_sasl_start_len(VncState *vs, uint8_t *data, size
415 415 uint32_t startlen = read_u32(data, 0);
416 416 VNC_DEBUG("Got client start len %d\n", startlen);
417 417 if (startlen > SASL_DATA_MAX_LEN) {
418   - VNC_DEBUG("Too much SASL data %d\n", startlen);
419   - vnc_client_error(vs);
420   - return -1;
  418 + VNC_DEBUG("Too much SASL data %d\n", startlen);
  419 + vnc_client_error(vs);
  420 + return -1;
421 421 }
422 422  
423 423 if (startlen == 0)
424   - return protocol_client_auth_sasl_start(vs, NULL, 0);
  424 + return protocol_client_auth_sasl_start(vs, NULL, 0);
425 425  
426 426 vnc_read_when(vs, protocol_client_auth_sasl_start, startlen);
427 427 return 0;
... ... @@ -431,35 +431,35 @@ static int protocol_client_auth_sasl_mechname(VncState *vs, uint8_t *data, size_
431 431 {
432 432 char *mechname = malloc(len + 1);
433 433 if (!mechname) {
434   - VNC_DEBUG("Out of memory reading mechname\n");
435   - vnc_client_error(vs);
  434 + VNC_DEBUG("Out of memory reading mechname\n");
  435 + vnc_client_error(vs);
436 436 }
437 437 strncpy(mechname, (char*)data, len);
438 438 mechname[len] = '\0';
439 439 VNC_DEBUG("Got client mechname '%s' check against '%s'\n",
440   - mechname, vs->sasl.mechlist);
  440 + mechname, vs->sasl.mechlist);
441 441  
442 442 if (strncmp(vs->sasl.mechlist, mechname, len) == 0) {
443   - if (vs->sasl.mechlist[len] != '\0' &&
444   - vs->sasl.mechlist[len] != ',') {
445   - VNC_DEBUG("One %d", vs->sasl.mechlist[len]);
446   - vnc_client_error(vs);
447   - return -1;
448   - }
  443 + if (vs->sasl.mechlist[len] != '\0' &&
  444 + vs->sasl.mechlist[len] != ',') {
  445 + VNC_DEBUG("One %d", vs->sasl.mechlist[len]);
  446 + vnc_client_error(vs);
  447 + return -1;
  448 + }
449 449 } else {
450   - char *offset = strstr(vs->sasl.mechlist, mechname);
451   - VNC_DEBUG("Two %p\n", offset);
452   - if (!offset) {
453   - vnc_client_error(vs);
454   - return -1;
455   - }
456   - VNC_DEBUG("Two '%s'\n", offset);
457   - if (offset[-1] != ',' ||
458   - (offset[len] != '\0'&&
459   - offset[len] != ',')) {
460   - vnc_client_error(vs);
461   - return -1;
462   - }
  450 + char *offset = strstr(vs->sasl.mechlist, mechname);
  451 + VNC_DEBUG("Two %p\n", offset);
  452 + if (!offset) {
  453 + vnc_client_error(vs);
  454 + return -1;
  455 + }
  456 + VNC_DEBUG("Two '%s'\n", offset);
  457 + if (offset[-1] != ',' ||
  458 + (offset[len] != '\0'&&
  459 + offset[len] != ',')) {
  460 + vnc_client_error(vs);
  461 + return -1;
  462 + }
463 463 }
464 464  
465 465 free(vs->sasl.mechlist);
... ... @@ -475,20 +475,20 @@ static int protocol_client_auth_sasl_mechname_len(VncState *vs, uint8_t *data, s
475 475 uint32_t mechlen = read_u32(data, 0);
476 476 VNC_DEBUG("Got client mechname len %d\n", mechlen);
477 477 if (mechlen > 100) {
478   - VNC_DEBUG("Too long SASL mechname data %d\n", mechlen);
479   - vnc_client_error(vs);
480   - return -1;
  478 + VNC_DEBUG("Too long SASL mechname data %d\n", mechlen);
  479 + vnc_client_error(vs);
  480 + return -1;
481 481 }
482 482 if (mechlen < 1) {
483   - VNC_DEBUG("Too short SASL mechname %d\n", mechlen);
484   - vnc_client_error(vs);
485   - return -1;
  483 + VNC_DEBUG("Too short SASL mechname %d\n", mechlen);
  484 + vnc_client_error(vs);
  485 + return -1;
486 486 }
487 487 vnc_read_when(vs, protocol_client_auth_sasl_mechname,mechlen);
488 488 return 0;
489 489 }
490 490  
491   -#define USES_X509_AUTH(vs) \
  491 +#define USES_X509_AUTH(vs) \
492 492 ((vs)->subauth == VNC_AUTH_VENCRYPT_X509NONE || \
493 493 (vs)->subauth == VNC_AUTH_VENCRYPT_X509VNC || \
494 494 (vs)->subauth == VNC_AUTH_VENCRYPT_X509PLAIN || \
... ... @@ -507,116 +507,116 @@ void start_auth_sasl(VncState *vs)
507 507  
508 508 /* Get local & remote client addresses in form IPADDR;PORT */
509 509 if (!(localAddr = vnc_socket_local_addr("%s;%s", vs->csock)))
510   - goto authabort;
  510 + goto authabort;
511 511  
512 512 if (!(remoteAddr = vnc_socket_remote_addr("%s;%s", vs->csock))) {
513   - free(localAddr);
514   - goto authabort;
  513 + free(localAddr);
  514 + goto authabort;
515 515 }
516 516  
517 517 err = sasl_server_new("vnc",
518   - NULL, /* FQDN - just delegates to gethostname */
519   - NULL, /* User realm */
520   - localAddr,
521   - remoteAddr,
522   - NULL, /* Callbacks, not needed */
523   - SASL_SUCCESS_DATA,
524   - &vs->sasl.conn);
  518 + NULL, /* FQDN - just delegates to gethostname */
  519 + NULL, /* User realm */
  520 + localAddr,
  521 + remoteAddr,
  522 + NULL, /* Callbacks, not needed */
  523 + SASL_SUCCESS_DATA,
  524 + &vs->sasl.conn);
525 525 free(localAddr);
526 526 free(remoteAddr);
527 527 localAddr = remoteAddr = NULL;
528 528  
529 529 if (err != SASL_OK) {
530   - VNC_DEBUG("sasl context setup failed %d (%s)",
531   - err, sasl_errstring(err, NULL, NULL));
532   - vs->sasl.conn = NULL;
533   - goto authabort;
  530 + VNC_DEBUG("sasl context setup failed %d (%s)",
  531 + err, sasl_errstring(err, NULL, NULL));
  532 + vs->sasl.conn = NULL;
  533 + goto authabort;
534 534 }
535 535  
536 536 #ifdef CONFIG_VNC_TLS
537 537 /* Inform SASL that we've got an external SSF layer from TLS/x509 */
538 538 if (vs->vd->auth == VNC_AUTH_VENCRYPT &&
539   - vs->vd->subauth == VNC_AUTH_VENCRYPT_X509SASL) {
540   - gnutls_cipher_algorithm_t cipher;
541   - sasl_ssf_t ssf;
542   -
543   - cipher = gnutls_cipher_get(vs->tls.session);
544   - if (!(ssf = (sasl_ssf_t)gnutls_cipher_get_key_size(cipher))) {
545   - VNC_DEBUG("%s", "cannot TLS get cipher size\n");
546   - sasl_dispose(&vs->sasl.conn);
547   - vs->sasl.conn = NULL;
548   - goto authabort;
549   - }
550   - ssf *= 8; /* tls key size is bytes, sasl wants bits */
551   -
552   - err = sasl_setprop(vs->sasl.conn, SASL_SSF_EXTERNAL, &ssf);
553   - if (err != SASL_OK) {
554   - VNC_DEBUG("cannot set SASL external SSF %d (%s)\n",
555   - err, sasl_errstring(err, NULL, NULL));
556   - sasl_dispose(&vs->sasl.conn);
557   - vs->sasl.conn = NULL;
558   - goto authabort;
559   - }
  539 + vs->vd->subauth == VNC_AUTH_VENCRYPT_X509SASL) {
  540 + gnutls_cipher_algorithm_t cipher;
  541 + sasl_ssf_t ssf;
  542 +
  543 + cipher = gnutls_cipher_get(vs->tls.session);
  544 + if (!(ssf = (sasl_ssf_t)gnutls_cipher_get_key_size(cipher))) {
  545 + VNC_DEBUG("%s", "cannot TLS get cipher size\n");
  546 + sasl_dispose(&vs->sasl.conn);
  547 + vs->sasl.conn = NULL;
  548 + goto authabort;
  549 + }
  550 + ssf *= 8; /* tls key size is bytes, sasl wants bits */
  551 +
  552 + err = sasl_setprop(vs->sasl.conn, SASL_SSF_EXTERNAL, &ssf);
  553 + if (err != SASL_OK) {
  554 + VNC_DEBUG("cannot set SASL external SSF %d (%s)\n",
  555 + err, sasl_errstring(err, NULL, NULL));
  556 + sasl_dispose(&vs->sasl.conn);
  557 + vs->sasl.conn = NULL;
  558 + goto authabort;
  559 + }
560 560 } else
561 561 #endif /* CONFIG_VNC_TLS */
562   - vs->sasl.wantSSF = 1;
  562 + vs->sasl.wantSSF = 1;
563 563  
564 564 memset (&secprops, 0, sizeof secprops);
565 565 /* Inform SASL that we've got an external SSF layer from TLS */
566 566 if (strncmp(vs->vd->display, "unix:", 5) == 0
567 567 #ifdef CONFIG_VNC_TLS
568   - /* Disable SSF, if using TLS+x509+SASL only. TLS without x509
569   - is not sufficiently strong */
570   - || (vs->vd->auth == VNC_AUTH_VENCRYPT &&
571   - vs->vd->subauth == VNC_AUTH_VENCRYPT_X509SASL)
  568 + /* Disable SSF, if using TLS+x509+SASL only. TLS without x509
  569 + is not sufficiently strong */
  570 + || (vs->vd->auth == VNC_AUTH_VENCRYPT &&
  571 + vs->vd->subauth == VNC_AUTH_VENCRYPT_X509SASL)
572 572 #endif /* CONFIG_VNC_TLS */
573   - ) {
574   - /* If we've got TLS or UNIX domain sock, we don't care about SSF */
575   - secprops.min_ssf = 0;
576   - secprops.max_ssf = 0;
577   - secprops.maxbufsize = 8192;
578   - secprops.security_flags = 0;
  573 + ) {
  574 + /* If we've got TLS or UNIX domain sock, we don't care about SSF */
  575 + secprops.min_ssf = 0;
  576 + secprops.max_ssf = 0;
  577 + secprops.maxbufsize = 8192;
  578 + secprops.security_flags = 0;
579 579 } else {
580   - /* Plain TCP, better get an SSF layer */
581   - secprops.min_ssf = 56; /* Good enough to require kerberos */
582   - secprops.max_ssf = 100000; /* Arbitrary big number */
583   - secprops.maxbufsize = 8192;
584   - /* Forbid any anonymous or trivially crackable auth */
585   - secprops.security_flags =
586   - SASL_SEC_NOANONYMOUS | SASL_SEC_NOPLAINTEXT;
  580 + /* Plain TCP, better get an SSF layer */
  581 + secprops.min_ssf = 56; /* Good enough to require kerberos */
  582 + secprops.max_ssf = 100000; /* Arbitrary big number */
  583 + secprops.maxbufsize = 8192;
  584 + /* Forbid any anonymous or trivially crackable auth */
  585 + secprops.security_flags =
  586 + SASL_SEC_NOANONYMOUS | SASL_SEC_NOPLAINTEXT;
587 587 }
588 588  
589 589 err = sasl_setprop(vs->sasl.conn, SASL_SEC_PROPS, &secprops);
590 590 if (err != SASL_OK) {
591   - VNC_DEBUG("cannot set SASL security props %d (%s)\n",
592   - err, sasl_errstring(err, NULL, NULL));
593   - sasl_dispose(&vs->sasl.conn);
594   - vs->sasl.conn = NULL;
595   - goto authabort;
  591 + VNC_DEBUG("cannot set SASL security props %d (%s)\n",
  592 + err, sasl_errstring(err, NULL, NULL));
  593 + sasl_dispose(&vs->sasl.conn);
  594 + vs->sasl.conn = NULL;
  595 + goto authabort;
596 596 }
597 597  
598 598 err = sasl_listmech(vs->sasl.conn,
599   - NULL, /* Don't need to set user */
600   - "", /* Prefix */
601   - ",", /* Separator */
602   - "", /* Suffix */
603   - &mechlist,
604   - NULL,
605   - NULL);
  599 + NULL, /* Don't need to set user */
  600 + "", /* Prefix */
  601 + ",", /* Separator */
  602 + "", /* Suffix */
  603 + &mechlist,
  604 + NULL,
  605 + NULL);
606 606 if (err != SASL_OK) {
607   - VNC_DEBUG("cannot list SASL mechanisms %d (%s)\n",
608   - err, sasl_errdetail(vs->sasl.conn));
609   - sasl_dispose(&vs->sasl.conn);
610   - vs->sasl.conn = NULL;
611   - goto authabort;
  607 + VNC_DEBUG("cannot list SASL mechanisms %d (%s)\n",
  608 + err, sasl_errdetail(vs->sasl.conn));
  609 + sasl_dispose(&vs->sasl.conn);
  610 + vs->sasl.conn = NULL;
  611 + goto authabort;
612 612 }
613 613 VNC_DEBUG("Available mechanisms for client: '%s'\n", mechlist);
614 614  
615 615 if (!(vs->sasl.mechlist = strdup(mechlist))) {
616   - VNC_DEBUG("Out of memory");
617   - sasl_dispose(&vs->sasl.conn);
618   - vs->sasl.conn = NULL;
619   - goto authabort;
  616 + VNC_DEBUG("Out of memory");
  617 + sasl_dispose(&vs->sasl.conn);
  618 + vs->sasl.conn = NULL;
  619 + goto authabort;
620 620 }
621 621 mechlistlen = strlen(mechlist);
622 622 vnc_write_u32(vs, mechlistlen);
... ...
... ... @@ -128,10 +128,10 @@ static const char *vnc_auth_name(VncDisplay *vd) {
128 128 return "vencrypt+x509+vnc";
129 129 case VNC_AUTH_VENCRYPT_X509PLAIN:
130 130 return "vencrypt+x509+plain";
131   - case VNC_AUTH_VENCRYPT_TLSSASL:
132   - return "vencrypt+tls+sasl";
133   - case VNC_AUTH_VENCRYPT_X509SASL:
134   - return "vencrypt+x509+sasl";
  131 + case VNC_AUTH_VENCRYPT_TLSSASL:
  132 + return "vencrypt+tls+sasl";
  133 + case VNC_AUTH_VENCRYPT_X509SASL:
  134 + return "vencrypt+x509+sasl";
135 135 default:
136 136 return "vencrypt";
137 137 }
... ... @@ -139,7 +139,7 @@ static const char *vnc_auth_name(VncDisplay *vd) {
139 139 return "vencrypt";
140 140 #endif
141 141 case VNC_AUTH_SASL:
142   - return "sasl";
  142 + return "sasl";
143 143 }
144 144 return "unknown";
145 145 }
... ... @@ -160,17 +160,17 @@ static void do_info_vnc_client(Monitor *mon, VncState *client)
160 160  
161 161 #ifdef CONFIG_VNC_TLS
162 162 if (client->tls.session &&
163   - client->tls.dname)
164   - monitor_printf(mon, " x509 dname: %s\n", client->tls.dname);
  163 + client->tls.dname)
  164 + monitor_printf(mon, " x509 dname: %s\n", client->tls.dname);
165 165 else
166   - monitor_printf(mon, " x509 dname: none\n");
  166 + monitor_printf(mon, " x509 dname: none\n");
167 167 #endif
168 168 #ifdef CONFIG_VNC_SASL
169 169 if (client->sasl.conn &&
170   - client->sasl.username)
171   - monitor_printf(mon, " username: %s\n", client->sasl.username);
  170 + client->sasl.username)
  171 + monitor_printf(mon, " username: %s\n", client->sasl.username);
172 172 else
173   - monitor_printf(mon, " username: none\n");
  173 + monitor_printf(mon, " username: none\n");
174 174 #endif
175 175 }
176 176  
... ... @@ -277,8 +277,8 @@ static void vnc_update(VncState *vs, int x, int y, int w, int h)
277 277 h = MIN(h, vs->serverds.height);
278 278  
279 279 for (; y < h; y++)
280   - for (i = 0; i < w; i += 16)
281   - vnc_set_bit(vs->dirty_row[y], (x + i) / 16);
  280 + for (i = 0; i < w; i += 16)
  281 + vnc_set_bit(vs->dirty_row[y], (x + i) / 16);
282 282 }
283 283  
284 284 static void vnc_dpy_update(DisplayState *ds, int x, int y, int w, int h)
... ... @@ -292,7 +292,7 @@ static void vnc_dpy_update(DisplayState *ds, int x, int y, int w, int h)
292 292 }
293 293  
294 294 static void vnc_framebuffer_update(VncState *vs, int x, int y, int w, int h,
295   - int32_t encoding)
  295 + int32_t encoding)
296 296 {
297 297 vnc_write_u16(vs, x);
298 298 vnc_write_u16(vs, y);
... ... @@ -305,12 +305,12 @@ static void vnc_framebuffer_update(VncState *vs, int x, int y, int w, int h,
305 305 void buffer_reserve(Buffer *buffer, size_t len)
306 306 {
307 307 if ((buffer->capacity - buffer->offset) < len) {
308   - buffer->capacity += (len + 1024);
309   - buffer->buffer = qemu_realloc(buffer->buffer, buffer->capacity);
310   - if (buffer->buffer == NULL) {
311   - fprintf(stderr, "vnc: out of memory\n");
312   - exit(1);
313   - }
  308 + buffer->capacity += (len + 1024);
  309 + buffer->buffer = qemu_realloc(buffer->buffer, buffer->capacity);
  310 + if (buffer->buffer == NULL) {
  311 + fprintf(stderr, "vnc: out of memory\n");
  312 + exit(1);
  313 + }
314 314 }
315 315 }
316 316  
... ... @@ -326,7 +326,7 @@ uint8_t *buffer_end(Buffer *buffer)
326 326  
327 327 void buffer_reset(Buffer *buffer)
328 328 {
329   - buffer->offset = 0;
  329 + buffer->offset = 0;
330 330 }
331 331  
332 332 void buffer_append(Buffer *buffer, const void *data, size_t len)
... ... @@ -344,8 +344,8 @@ static void vnc_resize(VncState *vs)
344 344 vs->old_data = qemu_realloc(vs->old_data, ds_get_linesize(ds) * ds_get_height(ds));
345 345  
346 346 if (vs->old_data == NULL) {
347   - fprintf(stderr, "vnc: memory allocation failed\n");
348   - exit(1);
  347 + fprintf(stderr, "vnc: memory allocation failed\n");
  348 + exit(1);
349 349 }
350 350  
351 351 if (ds_get_bytes_per_pixel(ds) != vs->serverds.pf.bytes_per_pixel)
... ... @@ -469,8 +469,8 @@ static void send_framebuffer_update_raw(VncState *vs, int x, int y, int w, int h
469 469  
470 470 row = ds_get_data(vs->ds) + y * ds_get_linesize(vs->ds) + x * ds_get_bytes_per_pixel(vs->ds);
471 471 for (i = 0; i < h; i++) {
472   - vs->write_pixels(vs, row, w * ds_get_bytes_per_pixel(vs->ds));
473   - row += ds_get_linesize(vs->ds);
  472 + vs->write_pixels(vs, row, w * ds_get_bytes_per_pixel(vs->ds));
  473 + row += ds_get_linesize(vs->ds);
474 474 }
475 475 }
476 476  
... ... @@ -520,11 +520,11 @@ static void send_framebuffer_update_hextile(VncState *vs, int x, int y, int w, i
520 520 last_bg = (uint8_t *) qemu_malloc(vs->serverds.pf.bytes_per_pixel);
521 521 has_fg = has_bg = 0;
522 522 for (j = y; j < (y + h); j += 16) {
523   - for (i = x; i < (x + w); i += 16) {
  523 + for (i = x; i < (x + w); i += 16) {
524 524 vs->send_hextile_tile(vs, i, j,
525 525 MIN(16, x + w - i), MIN(16, y + h - j),
526 526 last_bg, last_fg, &has_bg, &has_fg);
527   - }
  527 + }
528 528 }
529 529 free(last_fg);
530 530 free(last_bg);
... ... @@ -630,17 +630,17 @@ static void send_framebuffer_update_zlib(VncState *vs, int x, int y, int w, int
630 630 static void send_framebuffer_update(VncState *vs, int x, int y, int w, int h)
631 631 {
632 632 switch(vs->vnc_encoding) {
633   - case VNC_ENCODING_ZLIB:
634   - send_framebuffer_update_zlib(vs, x, y, w, h);
635   - break;
636   - case VNC_ENCODING_HEXTILE:
637   - vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_HEXTILE);
638   - send_framebuffer_update_hextile(vs, x, y, w, h);
639   - break;
640   - default:
641   - vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_RAW);
642   - send_framebuffer_update_raw(vs, x, y, w, h);
643   - break;
  633 + case VNC_ENCODING_ZLIB:
  634 + send_framebuffer_update_zlib(vs, x, y, w, h);
  635 + break;
  636 + case VNC_ENCODING_HEXTILE:
  637 + vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_HEXTILE);
  638 + send_framebuffer_update_hextile(vs, x, y, w, h);
  639 + break;
  640 + default:
  641 + vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_RAW);
  642 + send_framebuffer_update_raw(vs, x, y, w, h);
  643 + break;
644 644 }
645 645 }
646 646  
... ... @@ -675,11 +675,11 @@ static int find_dirty_height(VncState *vs, int y, int last_x, int x)
675 675 int h;
676 676  
677 677 for (h = 1; h < (vs->serverds.height - y); h++) {
678   - int tmp_x;
679   - if (!vnc_get_bit(vs->dirty_row[y + h], last_x))
680   - break;
681   - for (tmp_x = last_x; tmp_x < x; tmp_x++)
682   - vnc_clear_bit(vs->dirty_row[y + h], tmp_x);
  678 + int tmp_x;
  679 + if (!vnc_get_bit(vs->dirty_row[y + h], last_x))
  680 + break;
  681 + for (tmp_x = last_x; tmp_x < x; tmp_x++)
  682 + vnc_clear_bit(vs->dirty_row[y + h], tmp_x);
683 683 }
684 684  
685 685 return h;
... ... @@ -689,88 +689,88 @@ static void vnc_update_client(void *opaque)
689 689 {
690 690 VncState *vs = opaque;
691 691 if (vs->need_update && vs->csock != -1) {
692   - int y;
693   - uint8_t *row;
694   - char *old_row;
695   - uint32_t width_mask[VNC_DIRTY_WORDS];
696   - int n_rectangles;
697   - int saved_offset;
698   - int has_dirty = 0;
  692 + int y;
  693 + uint8_t *row;
  694 + char *old_row;
  695 + uint32_t width_mask[VNC_DIRTY_WORDS];
  696 + int n_rectangles;
  697 + int saved_offset;
  698 + int has_dirty = 0;
699 699  
700 700 vga_hw_update();
701 701  
702 702 vnc_set_bits(width_mask, (ds_get_width(vs->ds) / 16), VNC_DIRTY_WORDS);
703 703  
704   - /* Walk through the dirty map and eliminate tiles that
705   - really aren't dirty */
706   - row = ds_get_data(vs->ds);
707   - old_row = vs->old_data;
708   -
709   - for (y = 0; y < ds_get_height(vs->ds); y++) {
710   - if (vnc_and_bits(vs->dirty_row[y], width_mask, VNC_DIRTY_WORDS)) {
711   - int x;
712   - uint8_t *ptr;
713   - char *old_ptr;
714   -
715   - ptr = row;
716   - old_ptr = (char*)old_row;
717   -
718   - for (x = 0; x < ds_get_width(vs->ds); x += 16) {
719   - if (memcmp(old_ptr, ptr, 16 * ds_get_bytes_per_pixel(vs->ds)) == 0) {
720   - vnc_clear_bit(vs->dirty_row[y], (x / 16));
721   - } else {
722   - has_dirty = 1;
723   - memcpy(old_ptr, ptr, 16 * ds_get_bytes_per_pixel(vs->ds));
724   - }
725   -
726   - ptr += 16 * ds_get_bytes_per_pixel(vs->ds);
727   - old_ptr += 16 * ds_get_bytes_per_pixel(vs->ds);
728   - }
729   - }
730   -
731   - row += ds_get_linesize(vs->ds);
732   - old_row += ds_get_linesize(vs->ds);
733   - }
734   -
735   - if (!has_dirty && !vs->audio_cap) {
736   - qemu_mod_timer(vs->timer, qemu_get_clock(rt_clock) + VNC_REFRESH_INTERVAL);
737   - return;
738   - }
739   -
740   - /* Count rectangles */
741   - n_rectangles = 0;
742   - vnc_write_u8(vs, 0); /* msg id */
743   - vnc_write_u8(vs, 0);
744   - saved_offset = vs->output.offset;
745   - vnc_write_u16(vs, 0);
746   -
747   - for (y = 0; y < vs->serverds.height; y++) {
748   - int x;
749   - int last_x = -1;
750   - for (x = 0; x < vs->serverds.width / 16; x++) {
751   - if (vnc_get_bit(vs->dirty_row[y], x)) {
752   - if (last_x == -1) {
753   - last_x = x;
754   - }
755   - vnc_clear_bit(vs->dirty_row[y], x);
756   - } else {
757   - if (last_x != -1) {
758   - int h = find_dirty_height(vs, y, last_x, x);
759   - send_framebuffer_update(vs, last_x * 16, y, (x - last_x) * 16, h);
760   - n_rectangles++;
761   - }
762   - last_x = -1;
763   - }
764   - }
765   - if (last_x != -1) {
766   - int h = find_dirty_height(vs, y, last_x, x);
767   - send_framebuffer_update(vs, last_x * 16, y, (x - last_x) * 16, h);
768   - n_rectangles++;
769   - }
770   - }
771   - vs->output.buffer[saved_offset] = (n_rectangles >> 8) & 0xFF;
772   - vs->output.buffer[saved_offset + 1] = n_rectangles & 0xFF;
773   - vnc_flush(vs);
  704 + /* Walk through the dirty map and eliminate tiles that
  705 + really aren't dirty */
  706 + row = ds_get_data(vs->ds);
  707 + old_row = vs->old_data;
  708 +
  709 + for (y = 0; y < ds_get_height(vs->ds); y++) {
  710 + if (vnc_and_bits(vs->dirty_row[y], width_mask, VNC_DIRTY_WORDS)) {
  711 + int x;
  712 + uint8_t *ptr;
  713 + char *old_ptr;
  714 +
  715 + ptr = row;
  716 + old_ptr = (char*)old_row;
  717 +
  718 + for (x = 0; x < ds_get_width(vs->ds); x += 16) {
  719 + if (memcmp(old_ptr, ptr, 16 * ds_get_bytes_per_pixel(vs->ds)) == 0) {
  720 + vnc_clear_bit(vs->dirty_row[y], (x / 16));
  721 + } else {
  722 + has_dirty = 1;
  723 + memcpy(old_ptr, ptr, 16 * ds_get_bytes_per_pixel(vs->ds));
  724 + }
  725 +
  726 + ptr += 16 * ds_get_bytes_per_pixel(vs->ds);
  727 + old_ptr += 16 * ds_get_bytes_per_pixel(vs->ds);
  728 + }
  729 + }
  730 +
  731 + row += ds_get_linesize(vs->ds);
  732 + old_row += ds_get_linesize(vs->ds);
  733 + }
  734 +
  735 + if (!has_dirty && !vs->audio_cap) {
  736 + qemu_mod_timer(vs->timer, qemu_get_clock(rt_clock) + VNC_REFRESH_INTERVAL);
  737 + return;
  738 + }
  739 +
  740 + /* Count rectangles */
  741 + n_rectangles = 0;
  742 + vnc_write_u8(vs, 0); /* msg id */
  743 + vnc_write_u8(vs, 0);
  744 + saved_offset = vs->output.offset;
  745 + vnc_write_u16(vs, 0);
  746 +
  747 + for (y = 0; y < vs->serverds.height; y++) {
  748 + int x;
  749 + int last_x = -1;
  750 + for (x = 0; x < vs->serverds.width / 16; x++) {
  751 + if (vnc_get_bit(vs->dirty_row[y], x)) {
  752 + if (last_x == -1) {
  753 + last_x = x;
  754 + }
  755 + vnc_clear_bit(vs->dirty_row[y], x);
  756 + } else {
  757 + if (last_x != -1) {
  758 + int h = find_dirty_height(vs, y, last_x, x);
  759 + send_framebuffer_update(vs, last_x * 16, y, (x - last_x) * 16, h);
  760 + n_rectangles++;
  761 + }
  762 + last_x = -1;
  763 + }
  764 + }
  765 + if (last_x != -1) {
  766 + int h = find_dirty_height(vs, y, last_x, x);
  767 + send_framebuffer_update(vs, last_x * 16, y, (x - last_x) * 16, h);
  768 + n_rectangles++;
  769 + }
  770 + }
  771 + vs->output.buffer[saved_offset] = (n_rectangles >> 8) & 0xFF;
  772 + vs->output.buffer[saved_offset + 1] = n_rectangles & 0xFF;
  773 + vnc_flush(vs);
774 774  
775 775 }
776 776  
... ... @@ -863,15 +863,15 @@ int vnc_client_io_error(VncState *vs, int ret, int last_errno)
863 863 }
864 864 }
865 865  
866   - VNC_DEBUG("Closing down client sock %d %d\n", ret, ret < 0 ? last_errno : 0);
867   - qemu_set_fd_handler2(vs->csock, NULL, NULL, NULL, NULL);
868   - closesocket(vs->csock);
  866 + VNC_DEBUG("Closing down client sock %d %d\n", ret, ret < 0 ? last_errno : 0);
  867 + qemu_set_fd_handler2(vs->csock, NULL, NULL, NULL, NULL);
  868 + closesocket(vs->csock);
869 869 qemu_del_timer(vs->timer);
870 870 qemu_free_timer(vs->timer);
871 871 if (vs->input.buffer) qemu_free(vs->input.buffer);
872 872 if (vs->output.buffer) qemu_free(vs->output.buffer);
873 873 #ifdef CONFIG_VNC_TLS
874   - vnc_tls_client_cleanup(vs);
  874 + vnc_tls_client_cleanup(vs);
875 875 #endif /* CONFIG_VNC_TLS */
876 876 #ifdef CONFIG_VNC_SASL
877 877 vnc_sasl_client_cleanup(vs);
... ... @@ -895,7 +895,7 @@ int vnc_client_io_error(VncState *vs, int ret, int last_errno)
895 895 qemu_free(vs->old_data);
896 896 qemu_free(vs);
897 897  
898   - return 0;
  898 + return 0;
899 899 }
900 900 return ret;
901 901 }
... ... @@ -927,17 +927,17 @@ long vnc_client_write_buf(VncState *vs, const uint8_t *data, size_t datalen)
927 927 long ret;
928 928 #ifdef CONFIG_VNC_TLS
929 929 if (vs->tls.session) {
930   - ret = gnutls_write(vs->tls.session, data, datalen);
931   - if (ret < 0) {
932   - if (ret == GNUTLS_E_AGAIN)
933   - errno = EAGAIN;
934   - else
935   - errno = EIO;
936   - ret = -1;
937   - }
  930 + ret = gnutls_write(vs->tls.session, data, datalen);
  931 + if (ret < 0) {
  932 + if (ret == GNUTLS_E_AGAIN)
  933 + errno = EAGAIN;
  934 + else
  935 + errno = EIO;
  936 + ret = -1;
  937 + }
938 938 } else
939 939 #endif /* CONFIG_VNC_TLS */
940   - ret = send(vs->csock, data, datalen, 0);
  940 + ret = send(vs->csock, data, datalen, 0);
941 941 VNC_DEBUG("Wrote wire %p %d -> %ld\n", data, datalen, ret);
942 942 return vnc_client_io_error(vs, ret, socket_error());
943 943 }
... ... @@ -978,7 +978,7 @@ static long vnc_client_write_plain(VncState *vs)
978 978 vs->output.offset -= ret;
979 979  
980 980 if (vs->output.offset == 0) {
981   - qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
  981 + qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
982 982 }
983 983  
984 984 return ret;
... ... @@ -1032,17 +1032,17 @@ long vnc_client_read_buf(VncState *vs, uint8_t *data, size_t datalen)
1032 1032 long ret;
1033 1033 #ifdef CONFIG_VNC_TLS
1034 1034 if (vs->tls.session) {
1035   - ret = gnutls_read(vs->tls.session, data, datalen);
1036   - if (ret < 0) {
1037   - if (ret == GNUTLS_E_AGAIN)
1038   - errno = EAGAIN;
1039   - else
1040   - errno = EIO;
1041   - ret = -1;
1042   - }
  1035 + ret = gnutls_read(vs->tls.session, data, datalen);
  1036 + if (ret < 0) {
  1037 + if (ret == GNUTLS_E_AGAIN)
  1038 + errno = EAGAIN;
  1039 + else
  1040 + errno = EIO;
  1041 + ret = -1;
  1042 + }
1043 1043 } else
1044 1044 #endif /* CONFIG_VNC_TLS */
1045   - ret = recv(vs->csock, data, datalen, 0);
  1045 + ret = recv(vs->csock, data, datalen, 0);
1046 1046 VNC_DEBUG("Read wire %p %d -> %ld\n", data, datalen, ret);
1047 1047 return vnc_client_io_error(vs, ret, socket_error());
1048 1048 }
... ... @@ -1087,22 +1087,22 @@ void vnc_client_read(void *opaque)
1087 1087 #endif /* CONFIG_VNC_SASL */
1088 1088 ret = vnc_client_read_plain(vs);
1089 1089 if (!ret)
1090   - return;
  1090 + return;
1091 1091  
1092 1092 while (vs->read_handler && vs->input.offset >= vs->read_handler_expect) {
1093   - size_t len = vs->read_handler_expect;
1094   - int ret;
1095   -
1096   - ret = vs->read_handler(vs, vs->input.buffer, len);
1097   - if (vs->csock == -1)
1098   - return;
1099   -
1100   - if (!ret) {
1101   - memmove(vs->input.buffer, vs->input.buffer + len, (vs->input.offset - len));
1102   - vs->input.offset -= len;
1103   - } else {
1104   - vs->read_handler_expect = ret;
1105   - }
  1093 + size_t len = vs->read_handler_expect;
  1094 + int ret;
  1095 +
  1096 + ret = vs->read_handler(vs, vs->input.buffer, len);
  1097 + if (vs->csock == -1)
  1098 + return;
  1099 +
  1100 + if (!ret) {
  1101 + memmove(vs->input.buffer, vs->input.buffer + len, (vs->input.offset - len));
  1102 + vs->input.offset -= len;
  1103 + } else {
  1104 + vs->read_handler_expect = ret;
  1105 + }
1106 1106 }
1107 1107 }
1108 1108  
... ... @@ -1111,7 +1111,7 @@ void vnc_write(VncState *vs, const void *data, size_t len)
1111 1111 buffer_reserve(&vs->output, len);
1112 1112  
1113 1113 if (buffer_empty(&vs->output)) {
1114   - qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, vnc_client_write, vs);
  1114 + qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, vnc_client_write, vs);
1115 1115 }
1116 1116  
1117 1117 buffer_append(&vs->output, data, len);
... ... @@ -1152,7 +1152,7 @@ void vnc_write_u8(VncState *vs, uint8_t value)
1152 1152 void vnc_flush(VncState *vs)
1153 1153 {
1154 1154 if (vs->output.offset)
1155   - vnc_client_write(vs);
  1155 + vnc_client_write(vs);
1156 1156 }
1157 1157  
1158 1158 uint8_t read_u8(uint8_t *data, size_t offset)
... ... @@ -1168,13 +1168,13 @@ uint16_t read_u16(uint8_t *data, size_t offset)
1168 1168 int32_t read_s32(uint8_t *data, size_t offset)
1169 1169 {
1170 1170 return (int32_t)((data[offset] << 24) | (data[offset + 1] << 16) |
1171   - (data[offset + 2] << 8) | data[offset + 3]);
  1171 + (data[offset + 2] << 8) | data[offset + 3]);
1172 1172 }
1173 1173  
1174 1174 uint32_t read_u32(uint8_t *data, size_t offset)
1175 1175 {
1176 1176 return ((data[offset] << 24) | (data[offset + 1] << 16) |
1177   - (data[offset + 2] << 8) | data[offset + 3]);
  1177 + (data[offset + 2] << 8) | data[offset + 3]);
1178 1178 }
1179 1179  
1180 1180 static void client_cut_text(VncState *vs, size_t len, uint8_t *text)
... ... @@ -1184,13 +1184,13 @@ static void client_cut_text(VncState *vs, size_t len, uint8_t *text)
1184 1184 static void check_pointer_type_change(VncState *vs, int absolute)
1185 1185 {
1186 1186 if (vnc_has_feature(vs, VNC_FEATURE_POINTER_TYPE_CHANGE) && vs->absolute != absolute) {
1187   - vnc_write_u8(vs, 0);
1188   - vnc_write_u8(vs, 0);
1189   - vnc_write_u16(vs, 1);
1190   - vnc_framebuffer_update(vs, absolute, 0,
1191   - ds_get_width(vs->ds), ds_get_height(vs->ds),
  1187 + vnc_write_u8(vs, 0);
  1188 + vnc_write_u8(vs, 0);
  1189 + vnc_write_u16(vs, 1);
  1190 + vnc_framebuffer_update(vs, absolute, 0,
  1191 + ds_get_width(vs->ds), ds_get_height(vs->ds),
1192 1192 VNC_ENCODING_POINTER_TYPE_CHANGE);
1193   - vnc_flush(vs);
  1193 + vnc_flush(vs);
1194 1194 }
1195 1195 vs->absolute = absolute;
1196 1196 }
... ... @@ -1201,32 +1201,32 @@ static void pointer_event(VncState *vs, int button_mask, int x, int y)
1201 1201 int dz = 0;
1202 1202  
1203 1203 if (button_mask & 0x01)
1204   - buttons |= MOUSE_EVENT_LBUTTON;
  1204 + buttons |= MOUSE_EVENT_LBUTTON;
1205 1205 if (button_mask & 0x02)
1206   - buttons |= MOUSE_EVENT_MBUTTON;
  1206 + buttons |= MOUSE_EVENT_MBUTTON;
1207 1207 if (button_mask & 0x04)
1208   - buttons |= MOUSE_EVENT_RBUTTON;
  1208 + buttons |= MOUSE_EVENT_RBUTTON;
1209 1209 if (button_mask & 0x08)
1210   - dz = -1;
  1210 + dz = -1;
1211 1211 if (button_mask & 0x10)
1212   - dz = 1;
  1212 + dz = 1;
1213 1213  
1214 1214 if (vs->absolute) {
1215   - kbd_mouse_event(x * 0x7FFF / (ds_get_width(vs->ds) - 1),
1216   - y * 0x7FFF / (ds_get_height(vs->ds) - 1),
1217   - dz, buttons);
  1215 + kbd_mouse_event(x * 0x7FFF / (ds_get_width(vs->ds) - 1),
  1216 + y * 0x7FFF / (ds_get_height(vs->ds) - 1),
  1217 + dz, buttons);
1218 1218 } else if (vnc_has_feature(vs, VNC_FEATURE_POINTER_TYPE_CHANGE)) {
1219   - x -= 0x7FFF;
1220   - y -= 0x7FFF;
  1219 + x -= 0x7FFF;
  1220 + y -= 0x7FFF;
1221 1221  
1222   - kbd_mouse_event(x, y, dz, buttons);
  1222 + kbd_mouse_event(x, y, dz, buttons);
1223 1223 } else {
1224   - if (vs->last_x != -1)
1225   - kbd_mouse_event(x - vs->last_x,
1226   - y - vs->last_y,
1227   - dz, buttons);
1228   - vs->last_x = x;
1229   - vs->last_y = y;
  1224 + if (vs->last_x != -1)
  1225 + kbd_mouse_event(x - vs->last_x,
  1226 + y - vs->last_y,
  1227 + dz, buttons);
  1228 + vs->last_x = x;
  1229 + vs->last_y = y;
1230 1230 }
1231 1231  
1232 1232 check_pointer_type_change(vs, kbd_mouse_is_absolute());
... ... @@ -1274,8 +1274,8 @@ static void do_key_event(VncState *vs, int down, int keycode, int sym)
1274 1274 return;
1275 1275 }
1276 1276 break;
1277   - case 0x3a: /* CapsLock */
1278   - case 0x45: /* NumLock */
  1277 + case 0x3a: /* CapsLock */
  1278 + case 0x45: /* NumLock */
1279 1279 if (!down)
1280 1280 vs->modifiers_state[keycode] ^= 1;
1281 1281 break;
... ... @@ -1357,7 +1357,7 @@ static void key_event(VncState *vs, int down, uint32_t sym)
1357 1357 int keycode;
1358 1358  
1359 1359 if (sym >= 'A' && sym <= 'Z' && is_graphic_console())
1360   - sym = sym - 'A' + 'a';
  1360 + sym = sym - 'A' + 'a';
1361 1361  
1362 1362 keycode = keysym2scancode(vs->vd->kbd_layout, sym & 0xFFFF);
1363 1363 do_key_event(vs, down, keycode, sym);
... ... @@ -1374,8 +1374,8 @@ static void ext_key_event(VncState *vs, int down,
1374 1374 }
1375 1375  
1376 1376 static void framebuffer_update_request(VncState *vs, int incremental,
1377   - int x_position, int y_position,
1378   - int w, int h)
  1377 + int x_position, int y_position,
  1378 + int w, int h)
1379 1379 {
1380 1380 if (x_position > ds_get_width(vs->ds))
1381 1381 x_position = ds_get_width(vs->ds);
... ... @@ -1389,14 +1389,14 @@ static void framebuffer_update_request(VncState *vs, int incremental,
1389 1389 int i;
1390 1390 vs->need_update = 1;
1391 1391 if (!incremental) {
1392   - char *old_row = vs->old_data + y_position * ds_get_linesize(vs->ds);
  1392 + char *old_row = vs->old_data + y_position * ds_get_linesize(vs->ds);
1393 1393  
1394   - for (i = 0; i < h; i++) {
  1394 + for (i = 0; i < h; i++) {
1395 1395 vnc_set_bits(vs->dirty_row[y_position + i],
1396 1396 (ds_get_width(vs->ds) / 16), VNC_DIRTY_WORDS);
1397   - memset(old_row, 42, ds_get_width(vs->ds) * ds_get_bytes_per_pixel(vs->ds));
1398   - old_row += ds_get_linesize(vs->ds);
1399   - }
  1397 + memset(old_row, 42, ds_get_width(vs->ds) * ds_get_bytes_per_pixel(vs->ds));
  1398 + old_row += ds_get_linesize(vs->ds);
  1399 + }
1400 1400 }
1401 1401 }
1402 1402  
... ... @@ -1513,13 +1513,13 @@ static void set_pixel_conversion(VncState *vs)
1513 1513 }
1514 1514  
1515 1515 static void set_pixel_format(VncState *vs,
1516   - int bits_per_pixel, int depth,
1517   - int big_endian_flag, int true_color_flag,
1518   - int red_max, int green_max, int blue_max,
1519   - int red_shift, int green_shift, int blue_shift)
  1516 + int bits_per_pixel, int depth,
  1517 + int big_endian_flag, int true_color_flag,
  1518 + int red_max, int green_max, int blue_max,
  1519 + int red_shift, int green_shift, int blue_shift)
1520 1520 {
1521 1521 if (!true_color_flag) {
1522   - vnc_client_error(vs);
  1522 + vnc_client_error(vs);
1523 1523 return;
1524 1524 }
1525 1525  
... ... @@ -1606,65 +1606,65 @@ static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len)
1606 1606  
1607 1607 switch (data[0]) {
1608 1608 case 0:
1609   - if (len == 1)
1610   - return 20;
1611   -
1612   - set_pixel_format(vs, read_u8(data, 4), read_u8(data, 5),
1613   - read_u8(data, 6), read_u8(data, 7),
1614   - read_u16(data, 8), read_u16(data, 10),
1615   - read_u16(data, 12), read_u8(data, 14),
1616   - read_u8(data, 15), read_u8(data, 16));
1617   - break;
  1609 + if (len == 1)
  1610 + return 20;
  1611 +
  1612 + set_pixel_format(vs, read_u8(data, 4), read_u8(data, 5),
  1613 + read_u8(data, 6), read_u8(data, 7),
  1614 + read_u16(data, 8), read_u16(data, 10),
  1615 + read_u16(data, 12), read_u8(data, 14),
  1616 + read_u8(data, 15), read_u8(data, 16));
  1617 + break;
1618 1618 case 2:
1619   - if (len == 1)
1620   - return 4;
  1619 + if (len == 1)
  1620 + return 4;
1621 1621  
1622   - if (len == 4) {
  1622 + if (len == 4) {
1623 1623 limit = read_u16(data, 2);
1624 1624 if (limit > 0)
1625 1625 return 4 + (limit * 4);
1626 1626 } else
1627 1627 limit = read_u16(data, 2);
1628 1628  
1629   - for (i = 0; i < limit; i++) {
1630   - int32_t val = read_s32(data, 4 + (i * 4));
1631   - memcpy(data + 4 + (i * 4), &val, sizeof(val));
1632   - }
  1629 + for (i = 0; i < limit; i++) {
  1630 + int32_t val = read_s32(data, 4 + (i * 4));
  1631 + memcpy(data + 4 + (i * 4), &val, sizeof(val));
  1632 + }
1633 1633  
1634   - set_encodings(vs, (int32_t *)(data + 4), limit);
1635   - break;
  1634 + set_encodings(vs, (int32_t *)(data + 4), limit);
  1635 + break;
1636 1636 case 3:
1637   - if (len == 1)
1638   - return 10;
  1637 + if (len == 1)
  1638 + return 10;
1639 1639  
1640   - framebuffer_update_request(vs,
1641   - read_u8(data, 1), read_u16(data, 2), read_u16(data, 4),
1642   - read_u16(data, 6), read_u16(data, 8));
1643   - break;
  1640 + framebuffer_update_request(vs,
  1641 + read_u8(data, 1), read_u16(data, 2), read_u16(data, 4),
  1642 + read_u16(data, 6), read_u16(data, 8));
  1643 + break;
1644 1644 case 4:
1645   - if (len == 1)
1646   - return 8;
  1645 + if (len == 1)
  1646 + return 8;
1647 1647  
1648   - key_event(vs, read_u8(data, 1), read_u32(data, 4));
1649   - break;
  1648 + key_event(vs, read_u8(data, 1), read_u32(data, 4));
  1649 + break;
1650 1650 case 5:
1651   - if (len == 1)
1652   - return 6;
  1651 + if (len == 1)
  1652 + return 6;
1653 1653  
1654   - pointer_event(vs, read_u8(data, 1), read_u16(data, 2), read_u16(data, 4));
1655   - break;
  1654 + pointer_event(vs, read_u8(data, 1), read_u16(data, 2), read_u16(data, 4));
  1655 + break;
1656 1656 case 6:
1657   - if (len == 1)
1658   - return 8;
  1657 + if (len == 1)
  1658 + return 8;
1659 1659  
1660   - if (len == 8) {
  1660 + if (len == 8) {
1661 1661 uint32_t dlen = read_u32(data, 4);
1662 1662 if (dlen > 0)
1663 1663 return 8 + dlen;
1664 1664 }
1665 1665  
1666   - client_cut_text(vs, read_u32(data, 4), data + 8);
1667   - break;
  1666 + client_cut_text(vs, read_u32(data, 4), data + 8);
  1667 + break;
1668 1668 case 255:
1669 1669 if (len == 1)
1670 1670 return 2;
... ... @@ -1726,9 +1726,9 @@ static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len)
1726 1726 }
1727 1727 break;
1728 1728 default:
1729   - printf("Msg: %d\n", data[0]);
1730   - vnc_client_error(vs);
1731   - break;
  1729 + printf("Msg: %d\n", data[0]);
  1730 + vnc_client_error(vs);
  1731 + break;
1732 1732 }
1733 1733  
1734 1734 vnc_read_when(vs, protocol_client_msg, 1);
... ... @@ -1781,16 +1781,16 @@ static int protocol_client_auth_vnc(VncState *vs, uint8_t *data, size_t len)
1781 1781 unsigned char key[8];
1782 1782  
1783 1783 if (!vs->vd->password || !vs->vd->password[0]) {
1784   - VNC_DEBUG("No password configured on server");
1785   - vnc_write_u32(vs, 1); /* Reject auth */
1786   - if (vs->minor >= 8) {
1787   - static const char err[] = "Authentication failed";
1788   - vnc_write_u32(vs, sizeof(err));
1789   - vnc_write(vs, err, sizeof(err));
1790   - }
1791   - vnc_flush(vs);
1792   - vnc_client_error(vs);
1793   - return 0;
  1784 + VNC_DEBUG("No password configured on server");
  1785 + vnc_write_u32(vs, 1); /* Reject auth */
  1786 + if (vs->minor >= 8) {
  1787 + static const char err[] = "Authentication failed";
  1788 + vnc_write_u32(vs, sizeof(err));
  1789 + vnc_write(vs, err, sizeof(err));
  1790 + }
  1791 + vnc_flush(vs);
  1792 + vnc_client_error(vs);
  1793 + return 0;
1794 1794 }
1795 1795  
1796 1796 memcpy(response, vs->challenge, VNC_AUTH_CHALLENGE_SIZE);
... ... @@ -1805,19 +1805,19 @@ static int protocol_client_auth_vnc(VncState *vs, uint8_t *data, size_t len)
1805 1805  
1806 1806 /* Compare expected vs actual challenge response */
1807 1807 if (memcmp(response, data, VNC_AUTH_CHALLENGE_SIZE) != 0) {
1808   - VNC_DEBUG("Client challenge reponse did not match\n");
1809   - vnc_write_u32(vs, 1); /* Reject auth */
1810   - if (vs->minor >= 8) {
1811   - static const char err[] = "Authentication failed";
1812   - vnc_write_u32(vs, sizeof(err));
1813   - vnc_write(vs, err, sizeof(err));
1814   - }
1815   - vnc_flush(vs);
1816   - vnc_client_error(vs);
  1808 + VNC_DEBUG("Client challenge reponse did not match\n");
  1809 + vnc_write_u32(vs, 1); /* Reject auth */
  1810 + if (vs->minor >= 8) {
  1811 + static const char err[] = "Authentication failed";
  1812 + vnc_write_u32(vs, sizeof(err));
  1813 + vnc_write(vs, err, sizeof(err));
  1814 + }
  1815 + vnc_flush(vs);
  1816 + vnc_client_error(vs);
1817 1817 } else {
1818   - VNC_DEBUG("Accepting VNC challenge response\n");
1819   - vnc_write_u32(vs, 0); /* Accept auth */
1820   - vnc_flush(vs);
  1818 + VNC_DEBUG("Accepting VNC challenge response\n");
  1819 + vnc_write_u32(vs, 0); /* Accept auth */
  1820 + vnc_flush(vs);
1821 1821  
1822 1822 start_client_init(vs);
1823 1823 }
... ... @@ -1901,35 +1901,35 @@ static int protocol_version(VncState *vs, uint8_t *version, size_t len)
1901 1901 local[12] = 0;
1902 1902  
1903 1903 if (sscanf(local, "RFB %03d.%03d\n", &vs->major, &vs->minor) != 2) {
1904   - VNC_DEBUG("Malformed protocol version %s\n", local);
1905   - vnc_client_error(vs);
1906   - return 0;
  1904 + VNC_DEBUG("Malformed protocol version %s\n", local);
  1905 + vnc_client_error(vs);
  1906 + return 0;
1907 1907 }
1908 1908 VNC_DEBUG("Client request protocol version %d.%d\n", vs->major, vs->minor);
1909 1909 if (vs->major != 3 ||
1910   - (vs->minor != 3 &&
1911   - vs->minor != 4 &&
1912   - vs->minor != 5 &&
1913   - vs->minor != 7 &&
1914   - vs->minor != 8)) {
1915   - VNC_DEBUG("Unsupported client version\n");
1916   - vnc_write_u32(vs, VNC_AUTH_INVALID);
1917   - vnc_flush(vs);
1918   - vnc_client_error(vs);
1919   - return 0;
  1910 + (vs->minor != 3 &&
  1911 + vs->minor != 4 &&
  1912 + vs->minor != 5 &&
  1913 + vs->minor != 7 &&
  1914 + vs->minor != 8)) {
  1915 + VNC_DEBUG("Unsupported client version\n");
  1916 + vnc_write_u32(vs, VNC_AUTH_INVALID);
  1917 + vnc_flush(vs);
  1918 + vnc_client_error(vs);
  1919 + return 0;
1920 1920 }
1921 1921 /* Some broken clients report v3.4 or v3.5, which spec requires to be treated
1922 1922 * as equivalent to v3.3 by servers
1923 1923 */
1924 1924 if (vs->minor == 4 || vs->minor == 5)
1925   - vs->minor = 3;
  1925 + vs->minor = 3;
1926 1926  
1927 1927 if (vs->minor == 3) {
1928   - if (vs->vd->auth == VNC_AUTH_NONE) {
  1928 + if (vs->vd->auth == VNC_AUTH_NONE) {
1929 1929 VNC_DEBUG("Tell client auth none\n");
1930 1930 vnc_write_u32(vs, vs->vd->auth);
1931 1931 vnc_flush(vs);
1932   - start_client_init(vs);
  1932 + start_client_init(vs);
1933 1933 } else if (vs->vd->auth == VNC_AUTH_VNC) {
1934 1934 VNC_DEBUG("Tell client VNC auth\n");
1935 1935 vnc_write_u32(vs, vs->vd->auth);
... ... @@ -1942,11 +1942,11 @@ static int protocol_version(VncState *vs, uint8_t *version, size_t len)
1942 1942 vnc_client_error(vs);
1943 1943 }
1944 1944 } else {
1945   - VNC_DEBUG("Telling client we support auth %d\n", vs->vd->auth);
1946   - vnc_write_u8(vs, 1); /* num auth */
1947   - vnc_write_u8(vs, vs->vd->auth);
1948   - vnc_read_when(vs, protocol_client_auth, 1);
1949   - vnc_flush(vs);
  1945 + VNC_DEBUG("Telling client we support auth %d\n", vs->vd->auth);
  1946 + vnc_write_u8(vs, 1); /* num auth */
  1947 + vnc_write_u8(vs, vs->vd->auth);
  1948 + vnc_read_when(vs, protocol_client_auth, 1);
  1949 + vnc_flush(vs);
1950 1950 }
1951 1951  
1952 1952 return 0;
... ... @@ -2022,7 +2022,7 @@ void vnc_display_init(DisplayState *ds)
2022 2022 vs->kbd_layout = init_keyboard_layout(name2keysym, "en-us");
2023 2023  
2024 2024 if (!vs->kbd_layout)
2025   - exit(1);
  2025 + exit(1);
2026 2026  
2027 2027 dcl->dpy_copy = vnc_dpy_copy;
2028 2028 dcl->dpy_update = vnc_dpy_update;
... ... @@ -2039,13 +2039,13 @@ void vnc_display_close(DisplayState *ds)
2039 2039 if (!vs)
2040 2040 return;
2041 2041 if (vs->display) {
2042   - qemu_free(vs->display);
2043   - vs->display = NULL;
  2042 + qemu_free(vs->display);
  2043 + vs->display = NULL;
2044 2044 }
2045 2045 if (vs->lsock != -1) {
2046   - qemu_set_fd_handler2(vs->lsock, NULL, NULL, NULL, NULL);
2047   - close(vs->lsock);
2048   - vs->lsock = -1;
  2046 + qemu_set_fd_handler2(vs->lsock, NULL, NULL, NULL, NULL);
  2047 + close(vs->lsock);
  2048 + vs->lsock = -1;
2049 2049 }
2050 2050 vs->auth = VNC_AUTH_INVALID;
2051 2051 #ifdef CONFIG_VNC_TLS
... ... @@ -2059,12 +2059,12 @@ int vnc_display_password(DisplayState *ds, const char *password)
2059 2059 VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
2060 2060  
2061 2061 if (vs->password) {
2062   - qemu_free(vs->password);
2063   - vs->password = NULL;
  2062 + qemu_free(vs->password);
  2063 + vs->password = NULL;
2064 2064 }
2065 2065 if (password && password[0]) {
2066   - if (!(vs->password = qemu_strdup(password)))
2067   - return -1;
  2066 + if (!(vs->password = qemu_strdup(password)))
  2067 + return -1;
2068 2068 }
2069 2069  
2070 2070 return 0;
... ... @@ -2090,76 +2090,76 @@ int vnc_display_open(DisplayState *ds, const char *display)
2090 2090 return -1;
2091 2091 vnc_display_close(ds);
2092 2092 if (strcmp(display, "none") == 0)
2093   - return 0;
  2093 + return 0;
2094 2094  
2095 2095 if (!(vs->display = strdup(display)))
2096   - return -1;
  2096 + return -1;
2097 2097  
2098 2098 options = display;
2099 2099 while ((options = strchr(options, ','))) {
2100   - options++;
2101   - if (strncmp(options, "password", 8) == 0) {
2102   - password = 1; /* Require password auth */
2103   - } else if (strncmp(options, "reverse", 7) == 0) {
2104   - reverse = 1;
2105   - } else if (strncmp(options, "to=", 3) == 0) {
  2100 + options++;
  2101 + if (strncmp(options, "password", 8) == 0) {
  2102 + password = 1; /* Require password auth */
  2103 + } else if (strncmp(options, "reverse", 7) == 0) {
  2104 + reverse = 1;
  2105 + } else if (strncmp(options, "to=", 3) == 0) {
2106 2106 to_port = atoi(options+3) + 5900;
2107 2107 #ifdef CONFIG_VNC_SASL
2108   - } else if (strncmp(options, "sasl", 4) == 0) {
2109   - sasl = 1; /* Require SASL auth */
  2108 + } else if (strncmp(options, "sasl", 4) == 0) {
  2109 + sasl = 1; /* Require SASL auth */
2110 2110 #endif
2111 2111 #ifdef CONFIG_VNC_TLS
2112   - } else if (strncmp(options, "tls", 3) == 0) {
2113   - tls = 1; /* Require TLS */
2114   - } else if (strncmp(options, "x509", 4) == 0) {
2115   - char *start, *end;
2116   - x509 = 1; /* Require x509 certificates */
2117   - if (strncmp(options, "x509verify", 10) == 0)
2118   - vs->tls.x509verify = 1; /* ...and verify client certs */
2119   -
2120   - /* Now check for 'x509=/some/path' postfix
2121   - * and use that to setup x509 certificate/key paths */
2122   - start = strchr(options, '=');
2123   - end = strchr(options, ',');
2124   - if (start && (!end || (start < end))) {
2125   - int len = end ? end-(start+1) : strlen(start+1);
2126   - char *path = qemu_strndup(start + 1, len);
2127   -
2128   - VNC_DEBUG("Trying certificate path '%s'\n", path);
2129   - if (vnc_tls_set_x509_creds_dir(vs, path) < 0) {
2130   - fprintf(stderr, "Failed to find x509 certificates/keys in %s\n", path);
2131   - qemu_free(path);
2132   - qemu_free(vs->display);
2133   - vs->display = NULL;
2134   - return -1;
2135   - }
2136   - qemu_free(path);
2137   - } else {
2138   - fprintf(stderr, "No certificate path provided\n");
2139   - qemu_free(vs->display);
2140   - vs->display = NULL;
2141   - return -1;
2142   - }
  2112 + } else if (strncmp(options, "tls", 3) == 0) {
  2113 + tls = 1; /* Require TLS */
  2114 + } else if (strncmp(options, "x509", 4) == 0) {
  2115 + char *start, *end;
  2116 + x509 = 1; /* Require x509 certificates */
  2117 + if (strncmp(options, "x509verify", 10) == 0)
  2118 + vs->tls.x509verify = 1; /* ...and verify client certs */
  2119 +
  2120 + /* Now check for 'x509=/some/path' postfix
  2121 + * and use that to setup x509 certificate/key paths */
  2122 + start = strchr(options, '=');
  2123 + end = strchr(options, ',');
  2124 + if (start && (!end || (start < end))) {
  2125 + int len = end ? end-(start+1) : strlen(start+1);
  2126 + char *path = qemu_strndup(start + 1, len);
  2127 +
  2128 + VNC_DEBUG("Trying certificate path '%s'\n", path);
  2129 + if (vnc_tls_set_x509_creds_dir(vs, path) < 0) {
  2130 + fprintf(stderr, "Failed to find x509 certificates/keys in %s\n", path);
  2131 + qemu_free(path);
  2132 + qemu_free(vs->display);
  2133 + vs->display = NULL;
  2134 + return -1;
  2135 + }
  2136 + qemu_free(path);
  2137 + } else {
  2138 + fprintf(stderr, "No certificate path provided\n");
  2139 + qemu_free(vs->display);
  2140 + vs->display = NULL;
  2141 + return -1;
  2142 + }
2143 2143 #endif
2144   - } else if (strncmp(options, "acl", 3) == 0) {
2145   - acl = 1;
2146   - }
  2144 + } else if (strncmp(options, "acl", 3) == 0) {
  2145 + acl = 1;
  2146 + }
2147 2147 }
2148 2148  
2149 2149 #ifdef CONFIG_VNC_TLS
2150 2150 if (acl && x509 && vs->tls.x509verify) {
2151   - if (!(vs->tls.acl = qemu_acl_init("vnc.x509dname"))) {
2152   - fprintf(stderr, "Failed to create x509 dname ACL\n");
2153   - exit(1);
2154   - }
  2151 + if (!(vs->tls.acl = qemu_acl_init("vnc.x509dname"))) {
  2152 + fprintf(stderr, "Failed to create x509 dname ACL\n");
  2153 + exit(1);
  2154 + }
2155 2155 }
2156 2156 #endif
2157 2157 #ifdef CONFIG_VNC_SASL
2158 2158 if (acl && sasl) {
2159   - if (!(vs->sasl.acl = qemu_acl_init("vnc.username"))) {
2160   - fprintf(stderr, "Failed to create username ACL\n");
2161   - exit(1);
2162   - }
  2159 + if (!(vs->sasl.acl = qemu_acl_init("vnc.username"))) {
  2160 + fprintf(stderr, "Failed to create username ACL\n");
  2161 + exit(1);
  2162 + }
2163 2163 }
2164 2164 #endif
2165 2165  
... ... @@ -2181,22 +2181,22 @@ int vnc_display_open(DisplayState *ds, const char *display)
2181 2181 */
2182 2182 if (password) {
2183 2183 #ifdef CONFIG_VNC_TLS
2184   - if (tls) {
2185   - vs->auth = VNC_AUTH_VENCRYPT;
2186   - if (x509) {
2187   - VNC_DEBUG("Initializing VNC server with x509 password auth\n");
2188   - vs->subauth = VNC_AUTH_VENCRYPT_X509VNC;
2189   - } else {
2190   - VNC_DEBUG("Initializing VNC server with TLS password auth\n");
2191   - vs->subauth = VNC_AUTH_VENCRYPT_TLSVNC;
2192   - }
2193   - } else {
  2184 + if (tls) {
  2185 + vs->auth = VNC_AUTH_VENCRYPT;
  2186 + if (x509) {
  2187 + VNC_DEBUG("Initializing VNC server with x509 password auth\n");
  2188 + vs->subauth = VNC_AUTH_VENCRYPT_X509VNC;
  2189 + } else {
  2190 + VNC_DEBUG("Initializing VNC server with TLS password auth\n");
  2191 + vs->subauth = VNC_AUTH_VENCRYPT_TLSVNC;
  2192 + }
  2193 + } else {
2194 2194 #endif /* CONFIG_VNC_TLS */
2195   - VNC_DEBUG("Initializing VNC server with password auth\n");
2196   - vs->auth = VNC_AUTH_VNC;
  2195 + VNC_DEBUG("Initializing VNC server with password auth\n");
  2196 + vs->auth = VNC_AUTH_VNC;
2197 2197 #ifdef CONFIG_VNC_TLS
2198   - vs->subauth = VNC_AUTH_INVALID;
2199   - }
  2198 + vs->subauth = VNC_AUTH_INVALID;
  2199 + }
2200 2200 #endif /* CONFIG_VNC_TLS */
2201 2201 #ifdef CONFIG_VNC_SASL
2202 2202 } else if (sasl) {
... ... @@ -2204,15 +2204,15 @@ int vnc_display_open(DisplayState *ds, const char *display)
2204 2204 if (tls) {
2205 2205 vs->auth = VNC_AUTH_VENCRYPT;
2206 2206 if (x509) {
2207   - VNC_DEBUG("Initializing VNC server with x509 SASL auth\n");
  2207 + VNC_DEBUG("Initializing VNC server with x509 SASL auth\n");
2208 2208 vs->subauth = VNC_AUTH_VENCRYPT_X509SASL;
2209 2209 } else {
2210   - VNC_DEBUG("Initializing VNC server with TLS SASL auth\n");
  2210 + VNC_DEBUG("Initializing VNC server with TLS SASL auth\n");
2211 2211 vs->subauth = VNC_AUTH_VENCRYPT_TLSSASL;
2212 2212 }
2213 2213 } else {
2214 2214 #endif /* CONFIG_VNC_TLS */
2215   - VNC_DEBUG("Initializing VNC server with SASL auth\n");
  2215 + VNC_DEBUG("Initializing VNC server with SASL auth\n");
2216 2216 vs->auth = VNC_AUTH_SASL;
2217 2217 #ifdef CONFIG_VNC_TLS
2218 2218 vs->subauth = VNC_AUTH_INVALID;
... ... @@ -2221,22 +2221,22 @@ int vnc_display_open(DisplayState *ds, const char *display)
2221 2221 #endif /* CONFIG_VNC_SASL */
2222 2222 } else {
2223 2223 #ifdef CONFIG_VNC_TLS
2224   - if (tls) {
2225   - vs->auth = VNC_AUTH_VENCRYPT;
2226   - if (x509) {
2227   - VNC_DEBUG("Initializing VNC server with x509 no auth\n");
2228   - vs->subauth = VNC_AUTH_VENCRYPT_X509NONE;
2229   - } else {
2230   - VNC_DEBUG("Initializing VNC server with TLS no auth\n");
2231   - vs->subauth = VNC_AUTH_VENCRYPT_TLSNONE;
2232   - }
2233   - } else {
  2224 + if (tls) {
  2225 + vs->auth = VNC_AUTH_VENCRYPT;
  2226 + if (x509) {
  2227 + VNC_DEBUG("Initializing VNC server with x509 no auth\n");
  2228 + vs->subauth = VNC_AUTH_VENCRYPT_X509NONE;
  2229 + } else {
  2230 + VNC_DEBUG("Initializing VNC server with TLS no auth\n");
  2231 + vs->subauth = VNC_AUTH_VENCRYPT_TLSNONE;
  2232 + }
  2233 + } else {
2234 2234 #endif
2235   - VNC_DEBUG("Initializing VNC server with no auth\n");
2236   - vs->auth = VNC_AUTH_NONE;
  2235 + VNC_DEBUG("Initializing VNC server with no auth\n");
  2236 + vs->auth = VNC_AUTH_NONE;
2237 2237 #ifdef CONFIG_VNC_TLS
2238   - vs->subauth = VNC_AUTH_INVALID;
2239   - }
  2238 + vs->subauth = VNC_AUTH_INVALID;
  2239 + }
2240 2240 #endif
2241 2241 }
2242 2242  
... ...