Changes in / [ef904895:8fdb18e] in mainline


Ignore:
Location:
uspace
Files:
2 added
10 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/dnsres/dnsres.c

    ref904895 r8fdb18e  
    3434
    3535#include <errno.h>
     36#include <inet/addr.h>
    3637#include <inet/dnsr.h>
    3738#include <stdio.h>
    … …  
    4344{
    4445        printf("syntax: " NAME " <host-name>\n");
    45 }
    46 
    47 static int addr_format(inet_addr_t *addr, char **bufp)
    48 {
    49         int rc;
    50 
    51         rc = asprintf(bufp, "%d.%d.%d.%d", addr->ipv4 >> 24,
    52             (addr->ipv4 >> 16) & 0xff, (addr->ipv4 >> 8) & 0xff,
    53             addr->ipv4 & 0xff);
    54 
    55         if (rc < 0)
    56                 return ENOMEM;
    57 
    58         return EOK;
    5946}
    6047
    … …  
    7663        }
    7764
    78         rc = addr_format(&hinfo->addr, &saddr);
     65        rc = inet_addr_format(&hinfo->addr, &saddr);
    7966        if (rc != EOK) {
    8067                dnsr_hostinfo_destroy(hinfo);

  • uspace/app/inet/inet.c

    ref904895 r8fdb18e  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2013 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3636
    3737#include <errno.h>
     38#include <inet/addr.h>
    3839#include <inet/inetcfg.h>
    3940#include <loc.h>
    … …  
    5455}
    5556
    56 static int naddr_parse(const char *text, inet_naddr_t *naddr)
    57 {
    58         unsigned long a[4], bits;
    59         char *cp = (char *)text;
    60         int i;
    61 
    62         for (i = 0; i < 3; i++) {
    63                 a[i] = strtoul(cp, &cp, 10);
    64                 if (*cp != '.')
    65                         return EINVAL;
    66                 ++cp;
    67         }
    68 
    69         a[3] = strtoul(cp, &cp, 10);
    70         if (*cp != '/')
    71                 return EINVAL;
    72         ++cp;
    73 
    74         bits = strtoul(cp, &cp, 10);
    75         if (*cp != '\0')
    76                 return EINVAL;
    77 
    78         naddr->ipv4 = 0;
    79         for (i = 0; i < 4; i++) {
    80                 if (a[i] > 255)
    81                         return EINVAL;
    82                 naddr->ipv4 = (naddr->ipv4 << 8) | a[i];
    83         }
    84 
    85         if (bits > 31)
    86                 return EINVAL;
    87 
    88         naddr->bits = bits;
    89         return EOK;
    90 }
    91 
    92 static int addr_parse(const char *text, inet_addr_t *addr)
    93 {
    94         unsigned long a[4];
    95         char *cp = (char *)text;
    96         int i;
    97 
    98         for (i = 0; i < 3; i++) {
    99                 a[i] = strtoul(cp, &cp, 10);
    100                 if (*cp != '.')
    101                         return EINVAL;
    102                 ++cp;
    103         }
    104 
    105         a[3] = strtoul(cp, &cp, 10);
    106         if (*cp != '\0')
    107                 return EINVAL;
    108 
    109         addr->ipv4 = 0;
    110         for (i = 0; i < 4; i++) {
    111                 if (a[i] > 255)
    112                         return EINVAL;
    113                 addr->ipv4 = (addr->ipv4 << 8) | a[i];
    114         }
    115 
    116         return EOK;
    117 }
    118 
    119 static int naddr_format(inet_naddr_t *naddr, char **bufp)
    120 {
    121         int rc;
    122 
    123         rc = asprintf(bufp, "%d.%d.%d.%d/%d", naddr->ipv4 >> 24,
    124             (naddr->ipv4 >> 16) & 0xff, (naddr->ipv4 >> 8) & 0xff,
    125             naddr->ipv4 & 0xff, naddr->bits);
    126 
    127         if (rc < 0)
    128                 return ENOMEM;
    129 
    130         return EOK;
    131 }
    132 
    133 static int addr_format(inet_addr_t *addr, char **bufp)
    134 {
    135         int rc;
    136 
    137         rc = asprintf(bufp, "%d.%d.%d.%d", addr->ipv4 >> 24,
    138             (addr->ipv4 >> 16) & 0xff, (addr->ipv4 >> 8) & 0xff,
    139             addr->ipv4 & 0xff);
    140 
    141         if (rc < 0)
    142                 return ENOMEM;
    143 
    144         return EOK;
    145 }
    146 
    14757static int addr_create_static(int argc, char *argv[])
    14858{
    … …  
    17888        }
    17989
    180         rc = naddr_parse(addr_spec, &naddr);
     90        rc = inet_naddr_parse(addr_spec, &naddr);
    18191        if (rc != EOK) {
    18292                printf(NAME ": Invalid network address format '%s'.\n",
    … …  
    267177        route_name = argv[2];
    268178
    269         rc = naddr_parse(dest_str, &dest);
     179        rc = inet_naddr_parse(dest_str, &dest);
    270180        if (rc != EOK) {
    271181                printf(NAME ": Invalid network address format '%s'.\n",
    … …  
    274184        }
    275185
    276         rc = addr_parse(router_str, &router);
     186        rc = inet_addr_parse(router_str, &router);
    277187        if (rc != EOK) {
    278188                printf(NAME ": Invalid address format '%s'.\n", router_str);
    … …  
    366276                }
    367277
    368                 rc = naddr_format(&ainfo.naddr, &astr);
     278                rc = inet_naddr_format(&ainfo.naddr, &astr);
    369279                if (rc != EOK) {
    370280                        printf("Memory allocation failed.\n");
    … …  
    430340                }
    431341
    432                 rc = naddr_format(&srinfo.dest, &dest_str);
     342                rc = inet_naddr_format(&srinfo.dest, &dest_str);
    433343                if (rc != EOK) {
    434344                        printf("Memory allocation failed.\n");
    … …  
    437347                }
    438348
    439                 rc = addr_format(&srinfo.router, &router_str);
     349                rc = inet_addr_format(&srinfo.router, &router_str);
    440350                if (rc != EOK) {
    441351                        printf("Memory allocation failed.\n");

  • uspace/app/ping/ping.c

    ref904895 r8fdb18e  
    3838#include <fibril_synch.h>
    3939#include <inet/dnsr.h>
     40#include <inet/addr.h>
    4041#include <inet/inetping.h>
    4142#include <io/console.h>
    … …  
    7273}
    7374
    74 static int addr_parse(const char *text, inet_addr_t *addr)
    75 {
    76         unsigned long a[4];
    77         char *cp = (char *)text;
    78         int i;
    79 
    80         for (i = 0; i < 3; i++) {
    81                 a[i] = strtoul(cp, &cp, 10);
    82                 if (*cp != '.')
    83                         return EINVAL;
    84                 ++cp;
    85         }
    86 
    87         a[3] = strtoul(cp, &cp, 10);
    88         if (*cp != '\0')
    89                 return EINVAL;
    90 
    91         addr->ipv4 = 0;
    92         for (i = 0; i < 4; i++) {
    93                 if (a[i] > 255)
    94                         return EINVAL;
    95                 addr->ipv4 = (addr->ipv4 << 8) | a[i];
    96         }
    97 
    98         return EOK;
    99 }
    100 
    101 static int addr_format(inet_addr_t *addr, char **bufp)
    102 {
    103         int rc;
    104 
    105         rc = asprintf(bufp, "%d.%d.%d.%d", addr->ipv4 >> 24,
    106             (addr->ipv4 >> 16) & 0xff, (addr->ipv4 >> 8) & 0xff,
    107             addr->ipv4 & 0xff);
    108 
    109         if (rc < 0)
    110                 return ENOMEM;
    111 
    112         return EOK;
    113 }
    114 
    11575static void ping_signal_done(void)
    11676{
    … …  
    12686        int rc;
    12787
    128         rc = addr_format(&sdu->src, &asrc);
     88        rc = inet_addr_format(&sdu->src, &asrc);
    12989        if (rc != EOK)
    13090                return ENOMEM;
    13191
    132         rc = addr_format(&sdu->dest, &adest);
     92        rc = inet_addr_format(&sdu->dest, &adest);
    13393        if (rc != EOK) {
    13494                free(asrc);
    … …  
    242202
    243203        /* Parse destination address */
    244         rc = addr_parse(argv[argi], &dest_addr);
     204        rc = inet_addr_parse(argv[argi], &dest_addr);
    245205        if (rc != EOK) {
    246206                /* Try interpreting as a host name */
    … …  
    261221        }
    262222
    263         rc = addr_format(&src_addr, &asrc);
     223        rc = inet_addr_format(&src_addr, &asrc);
    264224        if (rc != EOK) {
    265225                printf(NAME ": Out of memory.\n");
    … …  
    267227        }
    268228
    269         rc = addr_format(&dest_addr, &adest);
     229        rc = inet_addr_format(&dest_addr, &adest);
    270230        if (rc != EOK) {
    271231                printf(NAME ": Out of memory.\n");

  • uspace/app/vlaunch/vlaunch.c

    ref904895 r8fdb18e  
    121121        }
    122122       
    123         pixel_t grd_bg = PIXEL(255, 240, 240, 240);
     123        pixel_t grd_bg = PIXEL(255, 255, 255, 255);
    124124        pixel_t btn_bg = PIXEL(255, 0, 0, 0);
    125125        pixel_t btn_fg = PIXEL(255, 240, 240, 240);
    126         pixel_t lbl_bg = PIXEL(255, 240, 240, 240);
     126        pixel_t lbl_bg = PIXEL(255, 255, 255, 255);
    127127        pixel_t lbl_fg = PIXEL(255, 0, 0, 0);
    128128       

  • uspace/lib/c/Makefile

    ref904895 r8fdb18e  
    9292        generic/task.c \
    9393        generic/futex.c \
     94        generic/inet/addr.c \
    9495        generic/inet.c \
    9596        generic/inetcfg.c \

  • uspace/lib/c/include/inet/inet.h

    ref904895 r8fdb18e  
    3636#define LIBC_INET_INET_H_
    3737
     38#include <inet/addr.h>
    3839#include <sys/types.h>
    3940
    4041#define INET_TTL_MAX 255
    41 
    42 typedef struct {
    43         uint32_t ipv4;
    44 } inet_addr_t;
    4542
    4643typedef struct {

  • uspace/lib/c/include/inet/inetcfg.h

    ref904895 r8fdb18e  
    3838#include <inet/inet.h>
    3939#include <sys/types.h>
    40 
    41 /** Network address */
    42 typedef struct {
    43         /** Address */
    44         uint32_t ipv4;
    45         /** Number of valid bits in @c ipv4 */
    46         int bits;
    47 } inet_naddr_t;
    4840
    4941/** Address object info */

  • uspace/lib/gui/window.c

    ref904895 r8fdb18e  
    424424
    425425        while (!list_empty(&win->events.list)) {
    426                 list_remove(list_first(&win->events.list));
     426                window_event_t *event = (window_event_t *) list_first(&win->events.list);
     427                list_remove(&event->link);
     428                free(event);
    427429        }
    428430

  • uspace/srv/hid/compositor/compositor.c

    ref904895 r8fdb18e  
    9090typedef struct {
    9191        link_t link;
     92        atomic_t ref_cnt;
    9293        service_id_t in_dsid;
    9394        service_id_t out_dsid;
    … …  
    138139} viewport_t;
    139140
     141static desktop_rect_t viewport_bound_rect;
    140142static FIBRIL_MUTEX_INITIALIZE(viewport_list_mtx);
    141143static LIST_INITIALIZE(viewport_list);
    … …  
    215217
    216218        link_initialize(&win->link);
     219        atomic_set(&win->ref_cnt, 0);
    217220        prodcons_initialize(&win->queue);
    218221        transform_identity(&win->transform);
    … …  
    232235static void window_destroy(window_t *win)
    233236{
    234         if (win) {
     237        if (win && atomic_get(&win->ref_cnt) == 0) {
     238                while (!list_empty(&win->queue.list)) {
     239                        window_event_t *event = (window_event_t *) list_first(&win->queue.list);
     240                        list_remove(&event->link);
     241                        free(event);
     242                }
     243
    235244                if (win->surface) {
    236245                        surface_destroy(win->surface);
    … …  
    310319}
    311320
     321static void comp_restrict_pointers(void)
     322{
     323        fibril_mutex_lock(&viewport_list_mtx);
     324
     325        sysarg_t x_res = coord_origin;
     326        sysarg_t y_res = coord_origin;
     327        sysarg_t w_res = 0;
     328        sysarg_t h_res = 0;
     329
     330        if (!list_empty(&viewport_list)) {
     331                viewport_t *vp = (viewport_t *) list_first(&viewport_list);
     332                x_res = vp->pos.x;
     333                y_res = vp->pos.y;
     334                surface_get_resolution(vp->surface, &w_res, &h_res);
     335        }
     336
     337        list_foreach(viewport_list, link) {
     338                viewport_t *vp = list_get_instance(link, viewport_t, link);
     339                sysarg_t w_vp, h_vp;
     340                surface_get_resolution(vp->surface, &w_vp, &h_vp);
     341                rectangle_union(
     342                    x_res, y_res, w_res, h_res,
     343                    vp->pos.x, vp->pos.y, w_vp, h_vp,
     344                    &x_res, &y_res, &w_res, &h_res);
     345        }
     346
     347        viewport_bound_rect.x = x_res;
     348        viewport_bound_rect.y = y_res;
     349        viewport_bound_rect.w = w_res;
     350        viewport_bound_rect.h = h_res;
     351
     352        fibril_mutex_unlock(&viewport_list_mtx);
     353
     354        fibril_mutex_lock(&pointer_list_mtx);
     355
     356        list_foreach(pointer_list, link) {
     357                pointer_t *ptr = list_get_instance(link, pointer_t, link);
     358                ptr->pos.x = ptr->pos.x > viewport_bound_rect.x ? ptr->pos.x : viewport_bound_rect.x;
     359                ptr->pos.y = ptr->pos.y > viewport_bound_rect.y ? ptr->pos.y : viewport_bound_rect.y;
     360                ptr->pos.x = ptr->pos.x < viewport_bound_rect.x + viewport_bound_rect.w ?
     361                    ptr->pos.x : viewport_bound_rect.x + viewport_bound_rect.w;
     362                ptr->pos.y = ptr->pos.y < viewport_bound_rect.y + viewport_bound_rect.h ?
     363                    ptr->pos.y : viewport_bound_rect.y + viewport_bound_rect.h;
     364        }
     365
     366        fibril_mutex_unlock(&pointer_list_mtx);
     367}
     368
    312369static void comp_damage(sysarg_t x_dmg_glob, sysarg_t y_dmg_glob,
    313370    sysarg_t w_dmg_glob, sysarg_t h_dmg_glob)
    … …  
    695752        }
    696753
     754        loc_service_unregister(win->in_dsid);
     755        loc_service_unregister(win->out_dsid);
     756
     757        /* In case the client was killed, input fibril of the window might be
     758         * still blocked on the condition within comp_window_get_event. */
     759        window_event_t *event_dummy = (window_event_t *) malloc(sizeof(window_event_t));
     760        if (event_dummy) {
     761                link_initialize(&event_dummy->link);
     762                prodcons_produce(&win->queue, &event_dummy->link);
     763        }
     764
    697765        /* Calculate damage. */
    698766        sysarg_t x = 0;
    … …  
    706774        }
    707775
    708         /* Release window resources. */
    709         loc_service_unregister(win->in_dsid);
    710         loc_service_unregister(win->out_dsid);
    711         while (!list_empty(&win->queue.list)) {
    712                 list_remove(list_first(&win->queue.list));
    713         }
    714         window_destroy(win);
    715 
    716776        comp_damage(x, y, width, height);
    717777
    … …  
    813873
    814874        if (win) {
     875                atomic_inc(&win->ref_cnt);
    815876                async_answer_0(iid, EOK);
    816877        } else {
    … …  
    825886
    826887                        if (!IPC_GET_IMETHOD(call)) {
    827                                 async_answer_0(callid, EINVAL);
     888                                async_answer_0(callid, EOK);
     889                                atomic_dec(&win->ref_cnt);
     890                                window_destroy(win);
    828891                                return;
    829892                        }
    … …  
    842905
    843906                        if (!IPC_GET_IMETHOD(call)) {
    844                                 async_answer_0(callid, EINVAL);
     907                                comp_window_close(win, callid, &call);
     908                                atomic_dec(&win->ref_cnt);
     909                                window_destroy(win);
    845910                                return;
    846911                        }
    … …  
    857922                                break;
    858923                        case WINDOW_CLOSE:
    859                                 comp_window_close(win, callid, &call);
     924                                /* Postpone the closing until the phone is hung up to cover
     925                                 * the case when the client is killed abruptly. */
     926                                async_answer_0(callid, EOK);
    860927                                break;
    861928                        case WINDOW_CLOSE_REQUEST:
    … …  
    911978        async_answer_0(iid, EOK);
    912979
     980        comp_restrict_pointers();
    913981        comp_damage(0, 0, UINT32_MAX, UINT32_MAX);
    914982}
    … …  
    9561024                fibril_mutex_unlock(&viewport_list_mtx);
    9571025                async_answer_0(iid, EOK);
     1026
     1027                comp_restrict_pointers();
     1028                comp_damage(0, 0, UINT32_MAX, UINT32_MAX);
    9581029        }
    9591030}
    … …  
    13911462        surface_get_resolution(pointer->cursor.states[pointer->state],
    13921463             &cursor_width, &cursor_height);
     1464        if (pointer->pos.x + dx < viewport_bound_rect.x) {
     1465                dx = -1 * (pointer->pos.x - viewport_bound_rect.x);
     1466        }
     1467        if (pointer->pos.y + dy < viewport_bound_rect.y) {
     1468                dy = -1 * (pointer->pos.y - viewport_bound_rect.y);
     1469        }
     1470        if (pointer->pos.x + dx > viewport_bound_rect.x + viewport_bound_rect.w) {
     1471                dx = (viewport_bound_rect.x + viewport_bound_rect.w - pointer->pos.x);
     1472        }
     1473        if (pointer->pos.y + dy > viewport_bound_rect.y + viewport_bound_rect.h) {
     1474                dy = (viewport_bound_rect.y + viewport_bound_rect.h - pointer->pos.y);
     1475        }
    13931476        pointer->pos.x += dx;
    13941477        pointer->pos.y += dy;
    … …  
    19101993                        fibril_mutex_unlock(&viewport_list_mtx);
    19111994
     1995                        comp_restrict_pointers();
    19121996                        comp_damage(x, y, width, height);
    19131997                } else {
    … …  
    21222206                return -1;
    21232207        }
    2124        
     2208
     2209        comp_restrict_pointers();
    21252210        comp_damage(0, 0, UINT32_MAX, UINT32_MAX);
    21262211       

  • uspace/srv/net/inetsrv/inetsrv.h

    ref904895 r8fdb18e  
    4040#include <adt/list.h>
    4141#include <stdbool.h>
     42#include <inet/addr.h>
    4243#include <inet/iplink.h>
    4344#include <ipc/loc.h>
    … …  
    6162        link_t client_list;
    6263} inetping_client_t;
    63 
    64 /** Host address */
    65 typedef struct {
    66         uint32_t ipv4;
    67 } inet_addr_t;
    68 
    69 /** Network address */
    70 typedef struct {
    71         /** Address */
    72         uint32_t ipv4;
    73         /** Number of valid bits in @c ipv4 */
    74         int bits;
    75 } inet_naddr_t;
    7664
    7765/** Address object info */
Note: See TracChangeset for help on using the changeset viewer.