| /* |
| * Copyright 2007 Luis R. Rodriguez <mcgrof@winlab.rutgers.edu> |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 as |
| * published by the Free Software Foundation. |
| * |
| * Compatibility file for Linux wireless for kernels 2.6.32. |
| */ |
| |
| #include <linux/compat.h> |
| #include <linux/netdevice.h> |
| |
| int __dev_addr_add(struct dev_addr_list **list, int *count, |
| void *addr, int alen, int glbl) |
| { |
| struct dev_addr_list *da; |
| |
| for (da = *list; da != NULL; da = da->next) { |
| if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 && |
| da->da_addrlen == alen) { |
| if (glbl) { |
| int old_glbl = da->da_gusers; |
| da->da_gusers = 1; |
| if (old_glbl) |
| return 0; |
| } |
| da->da_users++; |
| return 0; |
| } |
| } |
| |
| da = kzalloc(sizeof(*da), GFP_ATOMIC); |
| if (da == NULL) |
| return -ENOMEM; |
| memcpy(da->da_addr, addr, alen); |
| da->da_addrlen = alen; |
| da->da_users = 1; |
| da->da_gusers = glbl ? 1 : 0; |
| da->next = *list; |
| *list = da; |
| (*count)++; |
| return 0; |
| } |
| |
| int __dev_addr_delete(struct dev_addr_list **list, int *count, |
| void *addr, int alen, int glbl) |
| { |
| struct dev_addr_list *da; |
| |
| for (; (da = *list) != NULL; list = &da->next) { |
| if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 && |
| alen == da->da_addrlen) { |
| if (glbl) { |
| int old_glbl = da->da_gusers; |
| da->da_gusers = 0; |
| if (old_glbl == 0) |
| break; |
| } |
| if (--da->da_users) |
| return 0; |
| |
| *list = da->next; |
| kfree(da); |
| (*count)--; |
| return 0; |
| } |
| } |
| return -ENOENT; |
| } |
| |
| int __dev_addr_sync(struct dev_addr_list **to, int *to_count, |
| struct dev_addr_list **from, int *from_count) |
| { |
| struct dev_addr_list *da, *next; |
| int err = 0; |
| |
| da = *from; |
| while (da != NULL) { |
| next = da->next; |
| if (!da->da_synced) { |
| err = __dev_addr_add(to, to_count, |
| da->da_addr, da->da_addrlen, 0); |
| if (err < 0) |
| break; |
| da->da_synced = 1; |
| da->da_users++; |
| } else if (da->da_users == 1) { |
| __dev_addr_delete(to, to_count, |
| da->da_addr, da->da_addrlen, 0); |
| __dev_addr_delete(from, from_count, |
| da->da_addr, da->da_addrlen, 0); |
| } |
| da = next; |
| } |
| return err; |
| } |
| EXPORT_SYMBOL_GPL(__dev_addr_sync); |
| |
| void __dev_addr_unsync(struct dev_addr_list **to, int *to_count, |
| struct dev_addr_list **from, int *from_count) |
| { |
| struct dev_addr_list *da, *next; |
| |
| da = *from; |
| while (da != NULL) { |
| next = da->next; |
| if (da->da_synced) { |
| __dev_addr_delete(to, to_count, |
| da->da_addr, da->da_addrlen, 0); |
| da->da_synced = 0; |
| __dev_addr_delete(from, from_count, |
| da->da_addr, da->da_addrlen, 0); |
| } |
| da = next; |
| } |
| } |
| EXPORT_SYMBOL_GPL(__dev_addr_unsync); |
| |
| /* |
| * Nonzero if YEAR is a leap year (every 4 years, |
| * except every 100th isn't, and every 400th is). |
| */ |
| static int __isleap(long year) |
| { |
| return (year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0); |
| } |
| |
| /* do a mathdiv for long type */ |
| static long math_div(long a, long b) |
| { |
| return a / b - (a % b < 0); |
| } |
| |
| /* How many leap years between y1 and y2, y1 must less or equal to y2 */ |
| static long leaps_between(long y1, long y2) |
| { |
| long leaps1 = math_div(y1 - 1, 4) - math_div(y1 - 1, 100) |
| + math_div(y1 - 1, 400); |
| long leaps2 = math_div(y2 - 1, 4) - math_div(y2 - 1, 100) |
| + math_div(y2 - 1, 400); |
| return leaps2 - leaps1; |
| } |
| |
| /* How many days come before each month (0-12). */ |
| static const unsigned short __mon_yday[2][13] = { |
| /* Normal years. */ |
| {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365}, |
| /* Leap years. */ |
| {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366} |
| }; |
| |
| #define SECS_PER_HOUR (60 * 60) |
| #define SECS_PER_DAY (SECS_PER_HOUR * 24) |
| |
| /** |
| * time_to_tm - converts the calendar time to local broken-down time |
| * |
| * @totalsecs the number of seconds elapsed since 00:00:00 on January 1, 1970, |
| * Coordinated Universal Time (UTC). |
| * @offset offset seconds adding to totalsecs. |
| * @result pointer to struct tm variable to receive broken-down time |
| */ |
| void time_to_tm(time_t totalsecs, int offset, struct tm *result) |
| { |
| long days, rem, y; |
| const unsigned short *ip; |
| |
| days = totalsecs / SECS_PER_DAY; |
| rem = totalsecs % SECS_PER_DAY; |
| rem += offset; |
| while (rem < 0) { |
| rem += SECS_PER_DAY; |
| --days; |
| } |
| while (rem >= SECS_PER_DAY) { |
| rem -= SECS_PER_DAY; |
| ++days; |
| } |
| |
| result->tm_hour = rem / SECS_PER_HOUR; |
| rem %= SECS_PER_HOUR; |
| result->tm_min = rem / 60; |
| result->tm_sec = rem % 60; |
| |
| /* January 1, 1970 was a Thursday. */ |
| result->tm_wday = (4 + days) % 7; |
| if (result->tm_wday < 0) |
| result->tm_wday += 7; |
| |
| y = 1970; |
| |
| while (days < 0 || days >= (__isleap(y) ? 366 : 365)) { |
| /* Guess a corrected year, assuming 365 days per year. */ |
| long yg = y + math_div(days, 365); |
| |
| /* Adjust DAYS and Y to match the guessed year. */ |
| days -= (yg - y) * 365 + leaps_between(y, yg); |
| y = yg; |
| } |
| |
| result->tm_year = y - 1900; |
| |
| result->tm_yday = days; |
| |
| ip = __mon_yday[__isleap(y)]; |
| for (y = 11; days < ip[y]; y--) |
| continue; |
| days -= ip[y]; |
| |
| result->tm_mon = y; |
| result->tm_mday = days + 1; |
| } |
| EXPORT_SYMBOL(time_to_tm); |
| /* source: kernel/time/timeconv.c*/ |
| |